scriptbindingphysicslua51unsafe.cpp

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.10
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIGLUA
#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
#define SWIG_LUA_MODULE_GLOBAL


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif 
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif


/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
  
  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/* 
   Flags/methods for returning states.
   
   The SWIG conversion methods, as ConvertPtr, return an integer 
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).
   
   Use the following macros/flags to set or process the returning
   states.
   
   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
    delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }
    
   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {         
        if (<obj is ok>) {                 
          if (<need new object>) {             
            *ptr = <ptr to new allocated object>; 
            return SWIG_NEWOBJ;            
          } else {                     
            *ptr = <ptr to old object>;        
            return SWIG_OLDOBJ;            
          }                        
        } else {                       
          return SWIG_BADOBJ;              
        }                          
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call
 
      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0) 
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;         /* mangled name of this type */
  const char             *str;          /* human readable name of this type */
  swig_dycast_func        dcast;        /* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;         /* linked list of types that can cast into this type */
  void                   *clientdata;       /* language specific type data */
  int                    owndata;       /* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;         /* pointer to type that is equivalent to this type */
  swig_converter_func     converter;        /* function to cast the void pointers */
  struct swig_cast_info  *next;         /* pointer to next cast in linked list */
  struct swig_cast_info  *prev;         /* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;       /* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;              /* Number of types in this module */
  struct swig_module_info *next;        /* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;    /* Array of initially generated type structures */
  swig_cast_info         **cast_initial;    /* Array of initially generated casting structures */
  void                    *clientdata;      /* Language specific module data */
} swig_module_info;

/* 
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
          const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/* 
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/* 
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/* 
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;
  
  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
    SWIG_TypeClientData(tc, clientdata);
      }
    }    
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}
  
/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)
  
  We start searching at module start, and finish searching when start == end.  
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start, 
                            swig_module_info *end, 
                    const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      register size_t l = 0;
      register size_t r = iter->size - 1;
      do {
    /* since l+r >= 0, we can (>> 1) instead (/ 2) */
    register size_t i = (l + r) >> 1; 
    const char *iname = iter->types[i]->name;
    if (iname) {
      register int compare = strcmp(name, iname);
      if (compare == 0) {       
        return iter->types[i];
      } else if (compare < 0) {
        if (i) {
          r = i - 1;
        } else {
          break;
        }
      } else if (compare > 0) {
        l = i + 1;
      }
    } else {
      break; /* should never happen */
    }
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).
  
  We start searching at module start, and finish searching when start == end.  
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start, 
                     swig_module_info *end, 
             const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      register size_t i = 0;
      for (; i < iter->size; ++i) {
    if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
      return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }
  
  /* neither found a match */
  return 0;
}

/* 
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  register const unsigned char *u = (unsigned char *) ptr;
  register const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    register unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/* 
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  register unsigned char *u = (unsigned char *) ptr;
  register const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    register char d = *(c++);
    register unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    else 
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (d - ('a'-10));
    else 
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/* 
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * luarun.swg
 *
 * This file contains the runtime support for Lua modules
 * and includes code for managing global variables and pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

#include "lua.h"
#include "lauxlib.h"
#include <stdlib.h>  /* for malloc */
#include <assert.h>  /* for a few sanity tests */

/* -----------------------------------------------------------------------------
 * Lua flavors
 * ----------------------------------------------------------------------------- */

#define SWIG_LUA_FLAVOR_LUA 1
#define SWIG_LUA_FLAVOR_ELUA 2
#define SWIG_LUA_FLAVOR_ELUAC 3

#if !defined(SWIG_LUA_TARGET)
# error SWIG_LUA_TARGET not defined
#endif

#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
#  define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
#  define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
#  define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
#else /* SWIG_LUA_FLAVOR_LUA */
#  define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
#  define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
#  define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
#endif

#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
#  define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
#  define LSTRVAL LRO_STRVAL
#endif

/* -----------------------------------------------------------------------------
 * compatibility defines
 * ----------------------------------------------------------------------------- */

/* History of Lua C API length functions:  In Lua 5.0 (and before?)
   there was "lua_strlen".  In Lua 5.1, this was renamed "lua_objlen",
   but a compatibility define of "lua_strlen" was added.  In Lua 5.2,
   this function was again renamed, to "lua_rawlen" (to emphasize that
   it doesn't call the "__len" metamethod), and the compatibility
   define of lua_strlen was removed.  All SWIG uses have been updated
   to "lua_rawlen", and we add our own defines of that here for older
   versions of Lua.  */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
# define lua_rawlen lua_strlen
#elif LUA_VERSION_NUM == 501
# define lua_rawlen lua_objlen
#endif


/* lua_pushglobaltable is the recommended "future-proof" way to get
   the global table for Lua 5.2 and later.  Here we define
   lua_pushglobaltable ourselves for Lua versions before 5.2.  */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
#endif


/* -----------------------------------------------------------------------------
 * global swig types
 * ----------------------------------------------------------------------------- */
/* Constant table */
#define SWIG_LUA_INT     1
#define SWIG_LUA_FLOAT   2
#define SWIG_LUA_STRING  3
#define SWIG_LUA_POINTER 4
#define SWIG_LUA_BINARY  5
#define SWIG_LUA_CHAR    6

/* Structure for variable linking table */
typedef struct {
  const char *name;
  lua_CFunction get;
  lua_CFunction set;
} swig_lua_var_info;

/* Constant information structure */
typedef struct {
    int type;
    char *name;
    long lvalue;
    double dvalue;
    void   *pvalue;
    swig_type_info **ptype;
} swig_lua_const_info;

typedef struct {
  const char     *name;
  lua_CFunction   method;
} swig_lua_method;

typedef struct {
  const char     *name;
  lua_CFunction   getmethod;
  lua_CFunction   setmethod;
} swig_lua_attribute;

typedef struct swig_lua_class {
  const char    *name;
  swig_type_info   **type;
  lua_CFunction  constructor;
  void    (*destructor)(void *);
  swig_lua_method   *methods;
  swig_lua_attribute     *attributes;
  struct swig_lua_class **bases;
  const char **base_names;
} swig_lua_class;

/* this is the struct for wrapping all pointers in SwigLua
*/
typedef struct {
  swig_type_info   *type;
  int     own;  /* 1 if owned & must be destroyed */
  void        *ptr;
} swig_lua_userdata;

/* this is the struct for wrapping arbitrary packed binary data
(currently it is only used for member function pointers)
the data ordering is similar to swig_lua_userdata, but it is currently not possible
to tell the two structures apart within SWIG, other than by looking at the type
*/
typedef struct {
  swig_type_info   *type;
  int     own;  /* 1 if owned & must be destroyed */
  char data[1];       /* arbitary amount of data */    
} swig_lua_rawdata;

/* Common SWIG API */
#define SWIG_NewPointerObj(L, ptr, type, owner)       SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
#define SWIG_ConvertPtr(L,idx, ptr, type, flags)    SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname)  SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(L, idx, ptr, sz, ty)       SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
#define SWIG_NewMemberObj(L, ptr, sz, type)      SWIG_Lua_NewPackedObj(L, ptr, sz, type)

/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
#define SWIG_MODULE_CLIENTDATA_TYPE lua_State*

/* Contract support */
#define SWIG_contract_assert(expr, msg)  \
  if (!(expr)) { lua_pushstring(L, (char *) msg); goto fail; } else

/* helper #defines */
#define SWIG_fail {goto fail;}
#define SWIG_fail_arg(func_name,argnum,type) \
  {lua_pushfstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
  func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
  goto fail;}
#define SWIG_fail_ptr(func_name,argnum,type) \
  SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
#define SWIG_check_num_args(func_name,a,b) \
  if (lua_gettop(L)<a || lua_gettop(L)>b) \
  {lua_pushfstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
  goto fail;}


#define SWIG_Lua_get_table(L,n) \
  (lua_pushstring(L, n), lua_rawget(L,-2))

#define SWIG_Lua_add_function(L,n,f) \
  (lua_pushstring(L, n), \
      lua_pushcfunction(L, f), \
      lua_rawset(L,-3))

/* special helper for allowing 'nil' for usertypes */
#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))

#ifdef __cplusplus
/* Special helper for member function pointers 
it gets the address, casts it, then dereferences it */
//#define SWIG_mem_fn_as_voidptr(a)  (*((char**)&(a)))
#endif

/* storing/access of swig_module_info */
SWIGRUNTIME swig_module_info *
SWIG_Lua_GetModule(lua_State* L) {
  swig_module_info *ret = 0;
  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
  lua_rawget(L,LUA_REGISTRYINDEX);
  if (lua_islightuserdata(L,-1))
    ret=(swig_module_info*)lua_touserdata(L,-1);
  lua_pop(L,1);  /* tidy */
  return ret;
}

SWIGRUNTIME void
SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
  /* add this all into the Lua registry: */
  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
  lua_pushlightuserdata(L,(void*)module);
  lua_rawset(L,LUA_REGISTRYINDEX);
}

/* -----------------------------------------------------------------------------
 * global variable support code: modules
 * ----------------------------------------------------------------------------- */

/* this function is called when trying to set an immutable.
default action is to print an error.
This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
SWIGINTERN int SWIG_Lua_set_immutable(lua_State* L)
{
/*  there should be 1 param passed in: the new value */
#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
  lua_pop(L,1);  /* remove it */
  lua_pushstring(L,"This variable is immutable");
  lua_error(L);
#endif
    return 0;   /* should not return anything */
}

/* the module.get method used for getting linked data */
SWIGINTERN int SWIG_Lua_module_get(lua_State* L)
{
/*  there should be 2 params passed in
  (1) table (not the meta table)
  (2) string name of the attribute
  printf("SWIG_Lua_module_get %p(%s) '%s'\n",
   lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
   lua_tostring(L,2));
*/
  /* get the metatable */
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
  assert(lua_isrotable(L,1)); /* just in case */
#else
  assert(lua_istable(L,1)); /* default Lua action */
#endif
  lua_getmetatable(L,1);  /* get the metatable */
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
  assert(lua_isrotable(L,-1));  /* just in case */
#else
  assert(lua_istable(L,-1));
#endif
  SWIG_Lua_get_table(L,".get");  /* get the .get table */
  lua_remove(L,3);  /* remove metatable */
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
  if (lua_isrotable(L,-1))
#else
  if (lua_istable(L,-1))
#endif
  {
    /* look for the key in the .get table */
    lua_pushvalue(L,2);  /* key */
    lua_rawget(L,-2);
    lua_remove(L,3);  /* remove .get */
    if (lua_iscfunction(L,-1))
    {  /* found it so call the fn & return its value */
      lua_call(L,0,1);
      return 1;
    }
    lua_pop(L,1);  /* remove the top */
  }
  lua_pop(L,1);  /* remove the .get */
  lua_pushnil(L);  /* return a nil */
  return 1;
}

/* the module.set method used for setting linked data */
SWIGINTERN int SWIG_Lua_module_set(lua_State* L)
{
/*  there should be 3 params passed in
  (1) table (not the meta table)
  (2) string name of the attribute
  (3) any for the new value
*/
  /* get the metatable */
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
  assert(lua_isrotable(L,1));  /* just in case */
#else
  assert(lua_istable(L,1)); /* default Lua action */
#endif
  lua_getmetatable(L,1);  /* get the metatable */
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
  assert(lua_isrotable(L,-1));  /* just in case */
#else
  assert(lua_istable(L,-1));
#endif
  SWIG_Lua_get_table(L,".set");  /* get the .set table */
  lua_remove(L,4);  /* remove metatable */
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
  if (lua_isrotable(L,-1))
#else
  if (lua_istable(L,-1))
#endif
  {
    /* look for the key in the .set table */
    lua_pushvalue(L,2);  /* key */
    lua_rawget(L,-2);
    lua_remove(L,4);  /* remove .set */
    if (lua_iscfunction(L,-1))
    {  /* found it so call the fn & return its value */
      lua_pushvalue(L,3);  /* value */
      lua_call(L,1,0);
      return 0;
    }
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) 
    else {
      return 0; // Exits stoically if an invalid key is initialized.
    }
#endif
  }
  lua_settop(L,3);  /* reset back to start */
  /* we now have the table, key & new value, so just set directly */
  lua_rawset(L,1);  /* add direct */
  return 0;
}

#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
/* registering a module in lua. Pushes the module table on the stack. */
SWIGINTERN void  SWIG_Lua_module_begin(lua_State* L,const char* name)
{
  assert(lua_istable(L,-1));  /* just in case */
  lua_pushstring(L,name);
  lua_newtable(L);   /* the table */
  /* add meta table */
  lua_newtable(L);    /* the meta table */
  SWIG_Lua_add_function(L,"__index",SWIG_Lua_module_get);
  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_module_set);
  lua_pushstring(L,".get");
  lua_newtable(L);    /* the .get table */
  lua_rawset(L,-3);  /* add .get into metatable */
  lua_pushstring(L,".set");
  lua_newtable(L);    /* the .set table */
  lua_rawset(L,-3);  /* add .set into metatable */
  lua_setmetatable(L,-2);  /* sets meta table in module */
#ifdef SWIG_LUA_MODULE_GLOBAL
  /* If requested, install the module directly into the global namespace. */
  lua_rawset(L,-3);        /* add module into parent */
  SWIG_Lua_get_table(L,name);   /* get the table back out */
#else
  /* Do not install the module table as global name. The stack top has
     the module table with the name below. We pop the top and replace
     the name with it. */
  lua_replace(L,-2);
#endif
}

/* ending the register */
SWIGINTERN void  SWIG_Lua_module_end(lua_State* L)
{
  lua_pop(L,1);       /* tidy stack (remove module) */
}

/* adding a linked variable to the module */
SWIGINTERN void SWIG_Lua_module_add_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
{
  assert(lua_istable(L,-1));  /* just in case */
  lua_getmetatable(L,-1);  /* get the metatable */
  assert(lua_istable(L,-1));  /* just in case */
  SWIG_Lua_get_table(L,".get"); /* find the .get table */
  assert(lua_istable(L,-1));  /* should be a table: */
  SWIG_Lua_add_function(L,name,getFn);
  lua_pop(L,1);       /* tidy stack (remove table) */
  if (setFn)  /* if there is a set fn */
  {
    SWIG_Lua_get_table(L,".set"); /* find the .set table */
    assert(lua_istable(L,-1));  /* should be a table: */
    SWIG_Lua_add_function(L,name,setFn);
    lua_pop(L,1);       /* tidy stack (remove table) */
  }
  lua_pop(L,1);       /* tidy stack (remove meta) */
}
#endif

/* adding a function module */
SWIGINTERN void  SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_CFunction fn)
{
  SWIG_Lua_add_function(L,name,fn);
}

/* -----------------------------------------------------------------------------
 * global variable support code: classes
 * ----------------------------------------------------------------------------- */

/* the class.get method, performs the lookup of class attributes */
SWIGINTERN int  SWIG_Lua_class_get(lua_State* L)
{
/*  there should be 2 params passed in
  (1) userdata (not the meta table)
  (2) string name of the attribute
*/
  assert(lua_isuserdata(L,-2));  /* just in case */
  lua_getmetatable(L,-2);    /* get the meta table */
  assert(lua_istable(L,-1));  /* just in case */
  SWIG_Lua_get_table(L,".get"); /* find the .get table */
  assert(lua_istable(L,-1));  /* just in case */
  /* look for the key in the .get table */
  lua_pushvalue(L,2);  /* key */
  lua_rawget(L,-2);
  lua_remove(L,-2); /* stack tidy, remove .get table */
  if (lua_iscfunction(L,-1))
  {  /* found it so call the fn & return its value */
    lua_pushvalue(L,1);  /* the userdata */
    lua_call(L,1,1);  /* 1 value in (userdata),1 out (result) */
    lua_remove(L,-2); /* stack tidy, remove metatable */
    return 1;
  }
  lua_pop(L,1);  /* remove whatever was there */
  /* ok, so try the .fn table */
  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
  assert(lua_istable(L,-1));  /* just in case */
  lua_pushvalue(L,2);  /* key */
  lua_rawget(L,-2);  /* look for the fn */
  lua_remove(L,-2); /* stack tidy, remove .fn table */
  if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
  {  /* found it so return the fn & let lua call it */
    lua_remove(L,-2); /* stack tidy, remove metatable */
    return 1;
  }
  lua_pop(L,1);  /* remove whatever was there */
  /* NEW: looks for the __getitem() fn
  this is a user provided get fn */
  SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
  if (lua_iscfunction(L,-1))  /* if its there */
  {  /* found it so call the fn & return its value */
    lua_pushvalue(L,1);  /* the userdata */
    lua_pushvalue(L,2);  /* the parameter */
    lua_call(L,2,1);  /* 2 value in (userdata),1 out (result) */
    lua_remove(L,-2); /* stack tidy, remove metatable */
    return 1;
  }
  return 0;  /* sorry not known */
}

/* the class.set method, performs the lookup of class attributes */
SWIGINTERN int  SWIG_Lua_class_set(lua_State* L)
{
/*  there should be 3 params passed in
  (1) table (not the meta table)
  (2) string name of the attribute
  (3) any for the new value
printf("SWIG_Lua_class_set %p(%s) '%s' %p(%s)\n",
      lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
      lua_tostring(L,2),
      lua_topointer(L,3),lua_typename(L,lua_type(L,3)));*/

  assert(lua_isuserdata(L,1));  /* just in case */
  lua_getmetatable(L,1);    /* get the meta table */
  assert(lua_istable(L,-1));  /* just in case */

  SWIG_Lua_get_table(L,".set"); /* find the .set table */
  if (lua_istable(L,-1))
  {
    /* look for the key in the .set table */
    lua_pushvalue(L,2);  /* key */
    lua_rawget(L,-2);
    if (lua_iscfunction(L,-1))
    {  /* found it so call the fn & return its value */
      lua_pushvalue(L,1);  /* userdata */
      lua_pushvalue(L,3);  /* value */
      lua_call(L,2,0);
      return 0;
    }
    lua_pop(L,1);  /* remove the value */
  }
  lua_pop(L,1);  /* remove the value .set table */
  /* NEW: looks for the __setitem() fn
  this is a user provided set fn */
  SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
  if (lua_iscfunction(L,-1))  /* if its there */
  {  /* found it so call the fn & return its value */
    lua_pushvalue(L,1);  /* the userdata */
    lua_pushvalue(L,2);  /* the parameter */
    lua_pushvalue(L,3);  /* the value */
    lua_call(L,3,0);  /* 3 values in ,0 out */
    lua_remove(L,-2); /* stack tidy, remove metatable */
    return 1;
  }
  return 0;
}

/* the class.destruct method called by the interpreter */
SWIGINTERN int  SWIG_Lua_class_destruct(lua_State* L)
{
/*  there should be 1 params passed in
  (1) userdata (not the meta table) */
  swig_lua_userdata* usr;
  swig_lua_class* clss;
  assert(lua_isuserdata(L,-1));  /* just in case */
  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
  /* if must be destroyed & has a destructor */
  if (usr->own) /* if must be destroyed */
  {
    clss=(swig_lua_class*)usr->type->clientdata;  /* get the class */
    if (clss && clss->destructor)  /* there is a destroy fn */
    {
      clss->destructor(usr->ptr);  /* bye bye */
    }
  }
  return 0;
}

/* the class.__tostring method called by the interpreter and print */
SWIGINTERN int  SWIG_Lua_class_tostring(lua_State* L)
{
/*  there should be 1 param passed in
  (1) userdata (not the metatable) */
  assert(lua_isuserdata(L,1));  /* just in case */
  unsigned long userData = (unsigned long)lua_touserdata(L,1); /* get the userdata address for later */
  lua_getmetatable(L,1);    /* get the meta table */
  assert(lua_istable(L,-1));  /* just in case */
  
  lua_getfield(L, -1, ".type");
  const char* className = lua_tostring(L, -1);
  
  char output[256];
  sprintf(output, "<%s userdata: %lX>", className, userData);
  
  lua_pushstring(L, (const char*)output);
  return 1;
}

/* to manually disown some userdata */
SWIGINTERN int  SWIG_Lua_class_disown(lua_State* L)
{
/*  there should be 1 params passed in
  (1) userdata (not the meta table) */
  swig_lua_userdata* usr;
  assert(lua_isuserdata(L,-1));  /* just in case */
  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
  
  usr->own = 0; /* clear our ownership */
  return 0;
}

/* gets the swig class registry (or creates it) */
SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State* L)
{
  /* add this all into the swig registry: */
  lua_pushstring(L,"SWIG");
  lua_rawget(L,LUA_REGISTRYINDEX);  /* get the registry */
  if (!lua_istable(L,-1))  /* not there */
  {  /* must be first time, so add it */
    lua_pop(L,1);  /* remove the result */
    lua_pushstring(L,"SWIG");
    lua_newtable(L);
    lua_rawset(L,LUA_REGISTRYINDEX);
    /* then get it */
    lua_pushstring(L,"SWIG");
    lua_rawget(L,LUA_REGISTRYINDEX);
  }
}

/* helper fn to get the classes metatable from the register */
SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State* L,const char* cname)
{
  SWIG_Lua_get_class_registry(L);  /* get the registry */
  lua_pushstring(L,cname);  /* get the name */
  lua_rawget(L,-2);    /* get it */
  lua_remove(L,-2);    /* tidy up (remove registry) */
}

/* helper add a variable to a registered class */
SWIGINTERN void  SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
{
  assert(lua_istable(L,-1));  /* just in case */
  SWIG_Lua_get_table(L,".get"); /* find the .get table */
  assert(lua_istable(L,-1));  /* just in case */
  SWIG_Lua_add_function(L,name,getFn);
  lua_pop(L,1);       /* tidy stack (remove table) */
  if (setFn)
  {
    SWIG_Lua_get_table(L,".set"); /* find the .set table */
    assert(lua_istable(L,-1));  /* just in case */
    SWIG_Lua_add_function(L,name,setFn);
    lua_pop(L,1);       /* tidy stack (remove table) */
  }
}

/* helper to recursively add class details (attributes & operations) */
SWIGINTERN void  SWIG_Lua_add_class_details(lua_State* L,swig_lua_class* clss)
{
  int i;
  /* call all the base classes first: we can then override these later: */
  for(i=0;clss->bases[i];i++)
  {
    SWIG_Lua_add_class_details(L,clss->bases[i]);
  }
  /* add fns */
  for(i=0;clss->attributes[i].name;i++){
    SWIG_Lua_add_class_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
  }
  /* add methods to the metatable */
  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
  assert(lua_istable(L,-1));  /* just in case */
  for(i=0;clss->methods[i].name;i++){
    SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
  }
  lua_pop(L,1);       /* tidy stack (remove table) */
  /*   add operator overloads
    these look ANY method which start with "__" and assume they
    are operator overloads & add them to the metatable
    (this might mess up is someone defines a method __gc (the destructor)*/
  for(i=0;clss->methods[i].name;i++){
    if (clss->methods[i].name[0]=='_' && clss->methods[i].name[1]=='_'){
      SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
    }
  }
}

/* set up the base classes pointers.
Each class structure has a list of pointers to the base class structures.
This function fills them.
It cannot be done at compile time, as this will not work with hireachies
spread over more than one swig file. 
Therefore it must be done at runtime, querying the SWIG type system.
*/
SWIGINTERN void SWIG_Lua_init_base_class(lua_State* L,swig_lua_class* clss)
{
  int i=0;
  swig_module_info* module=SWIG_GetModule(L);
  for(i=0;clss->base_names[i];i++)
  {
    if (clss->bases[i]==0) /* not found yet */
    {
      /* lookup and cache the base class */
      swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
      if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
    }
  }
}

/* performs the entire class registration process */
SWIGINTERN void  SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
{
  /*  add its constructor to module with the name of the class
  so you can do MyClass(...) as well as new_MyClass(...)
  BUT only if a constructor is defined
  (this overcomes the problem of pure virtual classes without constructors)*/
  if (clss->constructor)
    SWIG_Lua_add_function(L,clss->name,clss->constructor);

  SWIG_Lua_get_class_registry(L);  /* get the registry */
  lua_pushstring(L,clss->name);  /* get the name */
  lua_newtable(L);    /* create the metatable */
  /* add string of class name called ".type" */
  lua_pushstring(L,".type");
  lua_pushstring(L,clss->name);
  lua_rawset(L,-3);
  /* add a table called ".get" */
  lua_pushstring(L,".get");
  lua_newtable(L);
  lua_rawset(L,-3);
  /* add a table called ".set" */
  lua_pushstring(L,".set");
  lua_newtable(L);
  lua_rawset(L,-3);
  /* add a table called ".fn" */
  lua_pushstring(L,".fn");
  lua_newtable(L);
  /* add manual disown method */
  SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
  lua_rawset(L,-3);
  /* add accessor fns for using the .get,.set&.fn */
  SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
  SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
  /* add tostring method for better output */
  SWIG_Lua_add_function(L,"__tostring",SWIG_Lua_class_tostring);
  /* add it */
  lua_rawset(L,-3);  /* metatable into registry */
  lua_pop(L,1);      /* tidy stack (remove registry) */

  SWIG_Lua_get_class_metatable(L,clss->name);
  SWIG_Lua_add_class_details(L,clss);  /* recursive adding of details (atts & ops) */
  lua_pop(L,1);      /* tidy stack (remove class metatable) */
}

/* -----------------------------------------------------------------------------
 * Class/structure conversion fns
 * ----------------------------------------------------------------------------- */

/* helper to add metatable to new lua object */
SWIGINTERN void _SWIG_Lua_AddMetatable(lua_State* L,swig_type_info *type)
{
  if (type->clientdata)  /* there is clientdata: so add the metatable */
  {
    SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->name);
    if (lua_istable(L,-1))
    {
      lua_setmetatable(L,-2);
    }
    else
    {
      lua_pop(L,1);
    }
  }
}

/* pushes a new object into the lua stack */
SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State* L,void* ptr,swig_type_info *type, int own)
{
  swig_lua_userdata* usr;
  if (!ptr){
    lua_pushnil(L);
    return;
  }
  usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata));  /* get data */
  usr->ptr=ptr;  /* set the ptr */
  usr->type=type;
  usr->own=own;
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
#endif
}

/* takes a object from the lua stack & converts it into an object of the correct type
 (if possible) */
SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State* L,int index,void** ptr,swig_type_info *type,int flags)
{
  swig_lua_userdata* usr;
  swig_cast_info *cast;
  if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;}    /* special case: lua nil => NULL pointer */
  usr=(swig_lua_userdata*)lua_touserdata(L,index);  /* get data */
  if (usr)
  {
    if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
    {
        usr->own=0;
    }
    if (!type)            /* special cast void*, no casting fn */
    {
      *ptr=usr->ptr;
      return SWIG_OK; /* ok */
    }
    cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
    if (cast)
    {
      int newmemory = 0;
      *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
      return SWIG_OK;  /* ok */
    }
  }
  return SWIG_ERROR;  /* error */
}

SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State* L,int index,swig_type_info *type,int flags,
       int argnum,const char* func_name){
  void* result;
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
    lua_pushfstring(L,"Error in %s, expected a %s at argument number %d\n",
      func_name,(type && type->str)?type->str:"void*",argnum);
    lua_error(L);
  }
  return result;
}

/* pushes a packed userdata. user for member fn pointers only */
SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State* L,void* ptr,size_t size,swig_type_info *type)
{
  swig_lua_rawdata* raw;
  assert(ptr); /* not acceptable to pass in a NULL value */
  raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size);  /* alloc data */
  raw->type=type;
  raw->own=0;
  memcpy(raw->data,ptr,size); /* copy the data */
  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
}
    
/* converts a packed userdata. user for member fn pointers only */
SWIGRUNTIME int  SWIG_Lua_ConvertPacked(lua_State* L,int index,void* ptr,size_t size,swig_type_info *type)
{
  swig_lua_rawdata* raw;
  raw=(swig_lua_rawdata*)lua_touserdata(L,index);  /* get data */
  if (!raw) return SWIG_ERROR;  /* error */
  if (type==0 || type==raw->type) /* void* or identical type */
  {
    memcpy(ptr,raw->data,size); /* copy it */
    return SWIG_OK; /* ok */
  }
  return SWIG_ERROR;  /* error */
}

/* a function to get the typestring of a piece of data */
SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
{
  swig_lua_userdata* usr;
  if (lua_isuserdata(L,tp))
  {
    usr=(swig_lua_userdata*)lua_touserdata(L,tp);  /* get data */
    if (usr && usr->type && usr->type->str)
      return usr->type->str;
    return "userdata (unknown type)";
  }
  return lua_typename(L,lua_type(L,tp));
}

/* lua callable function to get the userdata's type */
SWIGRUNTIME int SWIG_Lua_type(lua_State* L)
{
  lua_pushstring(L,SWIG_Lua_typename(L,1));
  return 1;
}

/* lua callable function to compare userdata's value
the issue is that two userdata may point to the same thing
but to lua, they are different objects */
SWIGRUNTIME int SWIG_Lua_equal(lua_State* L)
{
  int result;
  swig_lua_userdata *usr1,*usr2;
  if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2))  /* just in case */
    return 0;  /* nil reply */
  usr1=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
  usr2=(swig_lua_userdata*)lua_touserdata(L,2);  /* get data */
  /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
  result=(usr1->ptr==usr2->ptr);
   lua_pushboolean(L,result);
  return 1;
}

/* -----------------------------------------------------------------------------
 * global variable support code: class/struct typemap functions
 * ----------------------------------------------------------------------------- */

#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
/* Install Constants */
SWIGINTERN void
SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
  int i;
  for (i = 0; constants[i].type; i++) {
    switch(constants[i].type) {
    case SWIG_LUA_INT:
      lua_pushstring(L,constants[i].name);
      lua_pushnumber(L,(lua_Number)constants[i].lvalue);
      lua_rawset(L,-3);
      break;
    case SWIG_LUA_FLOAT:
      lua_pushstring(L,constants[i].name);
      lua_pushnumber(L,(lua_Number)constants[i].dvalue);
      lua_rawset(L,-3);
      break;
    case SWIG_LUA_CHAR:
      lua_pushstring(L,constants[i].name);
      lua_pushfstring(L,"%c",(char)constants[i].lvalue);
      lua_rawset(L,-3);
      break;
    case SWIG_LUA_STRING:
      lua_pushstring(L,constants[i].name);
      lua_pushstring(L,(char *) constants[i].pvalue);
      lua_rawset(L,-3);
      break;
    case SWIG_LUA_POINTER:
      lua_pushstring(L,constants[i].name);
      SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
      lua_rawset(L,-3);
      break;
    case SWIG_LUA_BINARY:
      lua_pushstring(L,constants[i].name);
      SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
      lua_rawset(L,-3);
      break;
    default:
      break;
    }
  }
}
#endif

/* -----------------------------------------------------------------------------
 * executing lua code from within the wrapper
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
#endif
/* Executes a C string in Lua which is a really simple way of calling lua from C
Unfortunately lua keeps changing its APIs, so we need a conditional compile
In lua 5.0.X its lua_dostring()
In lua 5.1.X its luaL_dostring()
*/
SWIGINTERN int 
SWIG_Lua_dostring(lua_State *L, const char* str) {
  int ok,top;
  if (str==0 || str[0]==0) return 0; /* nothing to do */
  top=lua_gettop(L); /* save stack */
#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
  ok=luaL_dostring(L,str);  /* looks like this is lua 5.1.X or later, good */
#else
  ok=lua_dostring(L,str);   /* might be lua 5.0.x, using lua_dostring */
#endif
  if (ok!=0) {
    SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
  }
  lua_settop(L,top); /* restore the stack */
  return ok;
}    

#ifdef __cplusplus
}
#endif

/* ------------------------------ end luarun.swg  ------------------------------ */

/*  Errors in SWIG */
#define  SWIG_UnknownError         -1 
#define  SWIG_IOError              -2 
#define  SWIG_RuntimeError         -3 
#define  SWIG_IndexError           -4 
#define  SWIG_TypeError            -5 
#define  SWIG_DivisionByZero       -6 
#define  SWIG_OverflowError        -7 
#define  SWIG_SyntaxError          -8 
#define  SWIG_ValueError           -9 
#define  SWIG_SystemError          -10
#define  SWIG_AttributeError       -11
#define  SWIG_MemoryError          -12 
#define  SWIG_NullReferenceError   -13




/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_AxisAlignedBox swig_types[0]
#define SWIGTYPE_p_AxisList swig_types[1]
#define SWIGTYPE_p_ChannelType swig_types[2]
#define SWIGTYPE_p_CollidablePair swig_types[3]
#define SWIGTYPE_p_CollisionContainer swig_types[4]
#define SWIGTYPE_p_CollisionIterator swig_types[5]
#define SWIGTYPE_p_CollisionShapeManager swig_types[6]
#define SWIGTYPE_p_CollisionSortPair swig_types[7]
#define SWIGTYPE_p_ConstCollisionIterator swig_types[8]
#define SWIGTYPE_p_ConstConstraintIterator swig_types[9]
#define SWIGTYPE_p_ConstProxyIterator swig_types[10]
#define SWIGTYPE_p_ConstShapeMapIterator swig_types[11]
#define SWIGTYPE_p_ConstShapeVectorIterator swig_types[12]
#define SWIGTYPE_p_ConstWorldTriggerIterator swig_types[13]
#define SWIGTYPE_p_ConstraintContainer swig_types[14]
#define SWIGTYPE_p_ConstraintIterator swig_types[15]
#define SWIGTYPE_p_ManagerBase swig_types[16]
#define SWIGTYPE_p_ManagerBase__ManagerType swig_types[17]
#define SWIGTYPE_p_ManagerConstructionInfo swig_types[18]
#define SWIGTYPE_p_Mezzanine__ArithmeticException swig_types[19]
#define SWIGTYPE_p_Mezzanine__AxisAlignedBox swig_types[20]
#define SWIGTYPE_p_Mezzanine__DirectoryException swig_types[21]
#define SWIGTYPE_p_Mezzanine__DirectoryNotFoundException swig_types[22]
#define SWIGTYPE_p_Mezzanine__DirectoryPermissionException swig_types[23]
#define SWIGTYPE_p_Mezzanine__DirectoryReadException swig_types[24]
#define SWIGTYPE_p_Mezzanine__DirectoryWriteException swig_types[25]
#define SWIGTYPE_p_Mezzanine__Exception swig_types[26]
#define SWIGTYPE_p_Mezzanine__FileException swig_types[27]
#define SWIGTYPE_p_Mezzanine__FileNotFoundException swig_types[28]
#define SWIGTYPE_p_Mezzanine__FilePermissionException swig_types[29]
#define SWIGTYPE_p_Mezzanine__FileReadException swig_types[30]
#define SWIGTYPE_p_Mezzanine__FileWriteException swig_types[31]
#define SWIGTYPE_p_Mezzanine__Graphics__Mesh swig_types[32]
#define SWIGTYPE_p_Mezzanine__IOException swig_types[33]
#define SWIGTYPE_p_Mezzanine__IOReadException swig_types[34]
#define SWIGTYPE_p_Mezzanine__IOWriteException swig_types[35]
#define SWIGTYPE_p_Mezzanine__InstanceIdentityDuplicateException swig_types[36]
#define SWIGTYPE_p_Mezzanine__InstanceIdentityException swig_types[37]
#define SWIGTYPE_p_Mezzanine__InstanceIdentityInvalidException swig_types[38]
#define SWIGTYPE_p_Mezzanine__InstanceIdentityNotFoundException swig_types[39]
#define SWIGTYPE_p_Mezzanine__InternalException swig_types[40]
#define SWIGTYPE_p_Mezzanine__InvalidAssignment swig_types[41]
#define SWIGTYPE_p_Mezzanine__InvalidStateException swig_types[42]
#define SWIGTYPE_p_Mezzanine__InvalidVersionException swig_types[43]
#define SWIGTYPE_p_Mezzanine__Matrix3x3 swig_types[44]
#define SWIGTYPE_p_Mezzanine__MemoryManagementException swig_types[45]
#define SWIGTYPE_p_Mezzanine__MemoryOutOfBoundsException swig_types[46]
#define SWIGTYPE_p_Mezzanine__NetworkException swig_types[47]
#define SWIGTYPE_p_Mezzanine__NetworkNotFoundException swig_types[48]
#define SWIGTYPE_p_Mezzanine__NetworkPermissionException swig_types[49]
#define SWIGTYPE_p_Mezzanine__NetworkReadException swig_types[50]
#define SWIGTYPE_p_Mezzanine__NetworkURLException swig_types[51]
#define SWIGTYPE_p_Mezzanine__NetworkWriteException swig_types[52]
#define SWIGTYPE_p_Mezzanine__NotImplementedException swig_types[53]
#define SWIGTYPE_p_Mezzanine__OutOfMemoryException swig_types[54]
#define SWIGTYPE_p_Mezzanine__ParametersCastException swig_types[55]
#define SWIGTYPE_p_Mezzanine__ParametersException swig_types[56]
#define SWIGTYPE_p_Mezzanine__ParametersRangeException swig_types[57]
#define SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape swig_types[58]
#define SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape swig_types[59]
#define SWIGTYPE_p_Mezzanine__Physics__CollidablePair swig_types[60]
#define SWIGTYPE_p_Mezzanine__Physics__CollidableProxy swig_types[61]
#define SWIGTYPE_p_Mezzanine__Physics__Collision swig_types[62]
#define SWIGTYPE_p_Mezzanine__Physics__CollisionShape swig_types[63]
#define SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer swig_types[64]
#define SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager swig_types[65]
#define SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator swig_types[66]
#define SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape swig_types[67]
#define SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape swig_types[68]
#define SWIGTYPE_p_Mezzanine__Physics__Constraint swig_types[69]
#define SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape swig_types[70]
#define SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape swig_types[71]
#define SWIGTYPE_p_Mezzanine__Physics__DebugDrawWorkUnit swig_types[72]
#define SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory swig_types[73]
#define SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory swig_types[74]
#define SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint swig_types[75]
#define SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape swig_types[76]
#define SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape swig_types[77]
#define SWIGTYPE_p_Mezzanine__Physics__GearConstraint swig_types[78]
#define SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint swig_types[79]
#define SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint swig_types[80]
#define SWIGTYPE_p_Mezzanine__Physics__GhostProxy swig_types[81]
#define SWIGTYPE_p_Mezzanine__Physics__HeightfieldCollisionShape swig_types[82]
#define SWIGTYPE_p_Mezzanine__Physics__HingeConstraint swig_types[83]
#define SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo swig_types[84]
#define SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape swig_types[85]
#define SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape swig_types[86]
#define SWIGTYPE_p_Mezzanine__Physics__PhysicsManager swig_types[87]
#define SWIGTYPE_p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator swig_types[88]
#define SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape swig_types[89]
#define SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint swig_types[90]
#define SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape swig_types[91]
#define SWIGTYPE_p_Mezzanine__Physics__RigidProxy swig_types[92]
#define SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit swig_types[93]
#define SWIGTYPE_p_Mezzanine__Physics__SimulationWorkUnit swig_types[94]
#define SWIGTYPE_p_Mezzanine__Physics__SliderConstraint swig_types[95]
#define SWIGTYPE_p_Mezzanine__Physics__SoftCollisionShape swig_types[96]
#define SWIGTYPE_p_Mezzanine__Physics__SoftProxy swig_types[97]
#define SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape swig_types[98]
#define SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape swig_types[99]
#define SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo swig_types[100]
#define SWIGTYPE_p_Mezzanine__Physics__StickyData swig_types[101]
#define SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint swig_types[102]
#define SWIGTYPE_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit swig_types[103]
#define SWIGTYPE_p_Mezzanine__Plane swig_types[104]
#define SWIGTYPE_p_Mezzanine__Quaternion swig_types[105]
#define SWIGTYPE_p_Mezzanine__Ray swig_types[106]
#define SWIGTYPE_p_Mezzanine__RenderingAPIException swig_types[107]
#define SWIGTYPE_p_Mezzanine__RuntimeAssertionException swig_types[108]
#define SWIGTYPE_p_Mezzanine__ScriptException swig_types[109]
#define SWIGTYPE_p_Mezzanine__ScriptLuaErrErrException swig_types[110]
#define SWIGTYPE_p_Mezzanine__ScriptLuaException swig_types[111]
#define SWIGTYPE_p_Mezzanine__ScriptLuaRuntimeException swig_types[112]
#define SWIGTYPE_p_Mezzanine__ScriptLuaYieldException swig_types[113]
#define SWIGTYPE_p_Mezzanine__SingletonT_CollisionShapeManager_t swig_types[114]
#define SWIGTYPE_p_Mezzanine__Sphere swig_types[115]
#define SWIGTYPE_p_Mezzanine__SyntaxErrorException swig_types[116]
#define SWIGTYPE_p_Mezzanine__SyntaxErrorLuaException swig_types[117]
#define SWIGTYPE_p_Mezzanine__SyntaxErrorXMLException swig_types[118]
#define SWIGTYPE_p_Mezzanine__SyntaxErrorXPathException swig_types[119]
#define SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type swig_types[120]
#define SWIGTYPE_p_Mezzanine__Threading__DefaultWorkUnit swig_types[121]
#define SWIGTYPE_p_Mezzanine__Threading__RawFile swig_types[122]
#define SWIGTYPE_p_Mezzanine__Transform swig_types[123]
#define SWIGTYPE_p_Mezzanine__TransformableChildObject swig_types[124]
#define SWIGTYPE_p_Mezzanine__TransformableObject swig_types[125]
#define SWIGTYPE_p_Mezzanine__Vector3 swig_types[126]
#define SWIGTYPE_p_Mezzanine__WorldManager swig_types[127]
#define SWIGTYPE_p_Mezzanine__WorldObject swig_types[128]
#define SWIGTYPE_p_Mezzanine__WorldProxy swig_types[129]
#define SWIGTYPE_p_Mezzanine__WorldTrigger swig_types[130]
#define SWIGTYPE_p_Ogre__Plane swig_types[131]
#define SWIGTYPE_p_Ogre__Quaternion swig_types[132]
#define SWIGTYPE_p_Ogre__Vector3 swig_types[133]
#define SWIGTYPE_p_ParamList swig_types[134]
#define SWIGTYPE_p_ProxyContainer swig_types[135]
#define SWIGTYPE_p_ProxyIterator swig_types[136]
#define SWIGTYPE_p_RayTestResult swig_types[137]
#define SWIGTYPE_p_SDL_Event swig_types[138]
#define SWIGTYPE_p_ShapeMap swig_types[139]
#define SWIGTYPE_p_ShapeMapIterator swig_types[140]
#define SWIGTYPE_p_ShapeVector swig_types[141]
#define SWIGTYPE_p_ShapeVectorIterator swig_types[142]
#define SWIGTYPE_p_StandardAxis swig_types[143]
#define SWIGTYPE_p_Transform swig_types[144]
#define SWIGTYPE_p_WorldTriggerContainer swig_types[145]
#define SWIGTYPE_p_WorldTriggerIterator swig_types[146]
#define SWIGTYPE_p_XML__Node swig_types[147]
#define SWIGTYPE_p_bool swig_types[148]
#define SWIGTYPE_p_btBoxShape swig_types[149]
#define SWIGTYPE_p_btBvhTriangleMeshShape swig_types[150]
#define SWIGTYPE_p_btCapsuleShape swig_types[151]
#define SWIGTYPE_p_btCollisionObject swig_types[152]
#define SWIGTYPE_p_btCollisionShape swig_types[153]
#define SWIGTYPE_p_btCompoundShape swig_types[154]
#define SWIGTYPE_p_btConcaveShape swig_types[155]
#define SWIGTYPE_p_btConeShape swig_types[156]
#define SWIGTYPE_p_btConvexHullShape swig_types[157]
#define SWIGTYPE_p_btConvexInternalShape swig_types[158]
#define SWIGTYPE_p_btCylinderShape swig_types[159]
#define SWIGTYPE_p_btGImpactMeshShape swig_types[160]
#define SWIGTYPE_p_btHeightfieldTerrainShape swig_types[161]
#define SWIGTYPE_p_btMultiSphereShape swig_types[162]
#define SWIGTYPE_p_btPairCachingGhostObject swig_types[163]
#define SWIGTYPE_p_btQuaternion swig_types[164]
#define SWIGTYPE_p_btRigidBody swig_types[165]
#define SWIGTYPE_p_btSoftBody swig_types[166]
#define SWIGTYPE_p_btSoftBodyCollisionShape swig_types[167]
#define SWIGTYPE_p_btSphereShape swig_types[168]
#define SWIGTYPE_p_btStaticPlaneShape swig_types[169]
#define SWIGTYPE_p_btTransform swig_types[170]
#define SWIGTYPE_p_btTypedConstraint swig_types[171]
#define SWIGTYPE_p_btVector3 swig_types[172]
#define SWIGTYPE_p_char swig_types[173]
#define SWIGTYPE_p_double swig_types[174]
#define SWIGTYPE_p_float swig_types[175]
#define SWIGTYPE_p_int swig_types[176]
#define SWIGTYPE_p_long_long swig_types[177]
#define SWIGTYPE_p_short swig_types[178]
#define SWIGTYPE_p_signed_char swig_types[179]
#define SWIGTYPE_p_std__exception swig_types[180]
#define SWIGTYPE_p_std__istream swig_types[181]
#define SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t swig_types[182]
#define SWIGTYPE_p_std__mapT_std__string_std__string_t swig_types[183]
#define SWIGTYPE_p_std__pairT_bool_Mezzanine__Vector3_t swig_types[184]
#define SWIGTYPE_p_std__pairT_std__string_std__string_t swig_types[185]
#define SWIGTYPE_p_std__setT_std__string_t swig_types[186]
#define SWIGTYPE_p_std__string swig_types[187]
#define SWIGTYPE_p_std__stringstream swig_types[188]
#define SWIGTYPE_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t swig_types[189]
#define SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t swig_types[190]
#define SWIGTYPE_p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t swig_types[191]
#define SWIGTYPE_p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t swig_types[192]
#define SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t swig_types[193]
#define SWIGTYPE_p_std__vectorT_float_t swig_types[194]
#define SWIGTYPE_p_std__vectorT_int_t swig_types[195]
#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[196]
#define SWIGTYPE_p_std__wstring swig_types[197]
#define SWIGTYPE_p_unsigned_char swig_types[198]
#define SWIGTYPE_p_unsigned_int swig_types[199]
#define SWIGTYPE_p_unsigned_long swig_types[200]
#define SWIGTYPE_p_unsigned_long_long swig_types[201]
#define SWIGTYPE_p_unsigned_short swig_types[202]
static swig_type_info *swig_types[204];
static swig_module_info swig_module = {swig_types, 203, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#define SWIG_name      "MezzaninePhysics"
#define SWIG_init      luaopen_MezzaninePhysics
#define SWIG_init_user luaopen_MezzaninePhysics_user

#define SWIG_LUACODE   luaopen_MezzaninePhysics_luacode

namespace swig {
typedef struct{} LANGUAGE_OBJ;
}


        // code to be inserted verbatim into the swig file goes here
        #include "mezzanine.h"
        #include "btBulletDynamicsCommon.h"
        #include "Ogre.h"
        #include "SDL.h"

        #ifdef GetCurrentTime
        #undef GetCurrentTime
        #endif

        #ifdef GetExceptionCode
        #undef GetExceptionCode
        #endif

        using namespace Mezzanine;
        //using namespace Mezzanine::Threading;
        //using namespace Mezzanine::Physics;

        // Fix cross module type-usage
        namespace Mezzanine
        {
            namespace Physics
            {
                typedef Mezzanine::Vector3 Vector3;
            }
            namespace Threading
            {

            }
            typedef Threading::RawFile RawFile;
        }
    

#include <stdexcept>


#define SWIG_exception(a,b)\
{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; }


#include <stdexcept>


#include <string>


SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
  int ret = lua_isstring(L, idx);
  if (!ret)
   ret = lua_isnil(L, idx);
  return ret;
}


#include <vector>


#include <map>
#include <algorithm>
#include <stdexcept>


#include <utility>


#include <stdint.h>     // Use the C99 official header


#include <deque>
#include <stdexcept>


        // code to be inserted verbatim into the swig file goes here
        #include "mezzanine.h"
        using namespace Mezzanine;
        using namespace Mezzanine::Physics;
    
#ifdef __cplusplus
extern "C" {
#endif
static int _wrap_new_string__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  std::string *result = 0 ;
  
  SWIG_check_num_args("std::string::string",0,0)
  result = (std::string *)new std::string();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_string__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  char *arg1 = (char *) 0 ;
  std::string *result = 0 ;
  
  SWIG_check_num_args("std::string::string",1,1)
  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *");
  arg1 = (char *)lua_tostring(L, 1);
  result = (std::string *)new std::string((char const *)arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_string(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_string__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      _v = SWIG_lua_isnilstring(L,argv[0]);
    }
    if (_v) {
      return _wrap_new_string__SWIG_1(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_string'\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::string::string()\n"
    "    std::string::string(char const *)\n");
  lua_error(L);return 0;
}


static int _wrap_string_size(lua_State* L) {
  int SWIG_arg = 0;
  std::string *arg1 = (std::string *) 0 ;
  unsigned int result;
  
  SWIG_check_num_args("std::string::size",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
    SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string);
  }
  
  result = (unsigned int)((std::string const *)arg1)->size();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_string_length(lua_State* L) {
  int SWIG_arg = 0;
  std::string *arg1 = (std::string *) 0 ;
  unsigned int result;
  
  SWIG_check_num_args("std::string::length",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
    SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string);
  }
  
  result = (unsigned int)((std::string const *)arg1)->length();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_string_empty(lua_State* L) {
  int SWIG_arg = 0;
  std::string *arg1 = (std::string *) 0 ;
  bool result;
  
  SWIG_check_num_args("std::string::empty",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
    SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string);
  }
  
  result = (bool)((std::string const *)arg1)->empty();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_string_c_str(lua_State* L) {
  int SWIG_arg = 0;
  std::string *arg1 = (std::string *) 0 ;
  char *result = 0 ;
  
  SWIG_check_num_args("std::string::c_str",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
    SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string);
  }
  
  result = (char *)((std::string const *)arg1)->c_str();
  lua_pushstring(L,(const char *)result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_string_data(lua_State* L) {
  int SWIG_arg = 0;
  std::string *arg1 = (std::string *) 0 ;
  char *result = 0 ;
  
  SWIG_check_num_args("std::string::data",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
    SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string);
  }
  
  result = (char *)((std::string const *)arg1)->data();
  lua_pushstring(L,(const char *)result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_string_assign(lua_State* L) {
  int SWIG_arg = 0;
  std::string *arg1 = (std::string *) 0 ;
  char *arg2 = (char *) 0 ;
  
  SWIG_check_num_args("std::string::assign",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *");
  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
    SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string);
  }
  
  arg2 = (char *)lua_tostring(L, 2);
  (arg1)->assign((char const *)arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_string(void *obj) {
std::string *arg1 = (std::string *) obj;
delete arg1;
}
static swig_lua_method swig_std_string_methods[] = {
    {"size", _wrap_string_size}, 
    {"length", _wrap_string_length}, 
    {"empty", _wrap_string_empty}, 
    {"c_str", _wrap_string_c_str}, 
    {"data", _wrap_string_data}, 
    {"assign", _wrap_string_assign}, 
    {0,0}
};
static swig_lua_attribute swig_std_string_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_std_string_bases[] = {0};
static const char *swig_std_string_base_names[] = {0};
static swig_lua_class _wrap_class_std_string = { "string", &SWIGTYPE_p_std__string,_wrap_new_string, swig_delete_string, swig_std_string_methods, swig_std_string_attributes, swig_std_string_bases, swig_std_string_base_names };

static int _wrap_new_SimulationWorkUnit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::SimulationWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SimulationWorkUnit::SimulationWorkUnit",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SimulationWorkUnit::SimulationWorkUnit",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_SimulationWorkUnit",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::SimulationWorkUnit *)new Mezzanine::Physics::SimulationWorkUnit(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SimulationWorkUnit,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SimulationWorkUnit_DoWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SimulationWorkUnit *arg1 = (Mezzanine::Physics::SimulationWorkUnit *) 0 ;
  Mezzanine::Threading::DefaultThreadSpecificStorage::Type *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SimulationWorkUnit::DoWork",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SimulationWorkUnit::DoWork",1,"Mezzanine::Physics::SimulationWorkUnit *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SimulationWorkUnit::DoWork",2,"Mezzanine::Threading::DefaultThreadSpecificStorage::Type &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SimulationWorkUnit,0))){
    SWIG_fail_ptr("SimulationWorkUnit_DoWork",1,SWIGTYPE_p_Mezzanine__Physics__SimulationWorkUnit);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,0))){
    SWIG_fail_ptr("SimulationWorkUnit_DoWork",2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type);
  }
  
  (arg1)->DoWork(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SimulationWorkUnit(void *obj) {
Mezzanine::Physics::SimulationWorkUnit *arg1 = (Mezzanine::Physics::SimulationWorkUnit *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_SimulationWorkUnit_methods[] = {
    {"DoWork", _wrap_SimulationWorkUnit_DoWork}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_SimulationWorkUnit_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_SimulationWorkUnit_bases[] = {0};
static const char *swig_Mezzanine_Physics_SimulationWorkUnit_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_SimulationWorkUnit = { "SimulationWorkUnit", &SWIGTYPE_p_Mezzanine__Physics__SimulationWorkUnit,_wrap_new_SimulationWorkUnit, swig_delete_SimulationWorkUnit, swig_Mezzanine_Physics_SimulationWorkUnit_methods, swig_Mezzanine_Physics_SimulationWorkUnit_attributes, swig_Mezzanine_Physics_SimulationWorkUnit_bases, swig_Mezzanine_Physics_SimulationWorkUnit_base_names };

static int _wrap_new_SimulationMonopolyWorkUnit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::SimulationMonopolyWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SimulationMonopolyWorkUnit::SimulationMonopolyWorkUnit",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SimulationMonopolyWorkUnit::SimulationMonopolyWorkUnit",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_SimulationMonopolyWorkUnit",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::SimulationMonopolyWorkUnit *)new Mezzanine::Physics::SimulationMonopolyWorkUnit(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SimulationMonopolyWorkUnit_UseThreads(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SimulationMonopolyWorkUnit *arg1 = (Mezzanine::Physics::SimulationMonopolyWorkUnit *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SimulationMonopolyWorkUnit::UseThreads",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SimulationMonopolyWorkUnit::UseThreads",1,"Mezzanine::Physics::SimulationMonopolyWorkUnit *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SimulationMonopolyWorkUnit::UseThreads",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit,0))){
    SWIG_fail_ptr("SimulationMonopolyWorkUnit_UseThreads",1,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->UseThreads((Mezzanine::Whole const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SimulationMonopolyWorkUnit_UsingThreadCount(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SimulationMonopolyWorkUnit *arg1 = (Mezzanine::Physics::SimulationMonopolyWorkUnit *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::SimulationMonopolyWorkUnit::UsingThreadCount",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SimulationMonopolyWorkUnit::UsingThreadCount",1,"Mezzanine::Physics::SimulationMonopolyWorkUnit *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit,0))){
    SWIG_fail_ptr("SimulationMonopolyWorkUnit_UsingThreadCount",1,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit);
  }
  
  result = (Mezzanine::Whole)(arg1)->UsingThreadCount();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SimulationMonopolyWorkUnit_DoWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SimulationMonopolyWorkUnit *arg1 = (Mezzanine::Physics::SimulationMonopolyWorkUnit *) 0 ;
  Mezzanine::Threading::DefaultThreadSpecificStorage::Type *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SimulationMonopolyWorkUnit::DoWork",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SimulationMonopolyWorkUnit::DoWork",1,"Mezzanine::Physics::SimulationMonopolyWorkUnit *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SimulationMonopolyWorkUnit::DoWork",2,"Mezzanine::Threading::DefaultThreadSpecificStorage::Type &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit,0))){
    SWIG_fail_ptr("SimulationMonopolyWorkUnit_DoWork",1,SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,0))){
    SWIG_fail_ptr("SimulationMonopolyWorkUnit_DoWork",2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type);
  }
  
  (arg1)->DoWork(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SimulationMonopolyWorkUnit(void *obj) {
Mezzanine::Physics::SimulationMonopolyWorkUnit *arg1 = (Mezzanine::Physics::SimulationMonopolyWorkUnit *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_methods[] = {
    {"UseThreads", _wrap_SimulationMonopolyWorkUnit_UseThreads}, 
    {"UsingThreadCount", _wrap_SimulationMonopolyWorkUnit_UsingThreadCount}, 
    {"DoWork", _wrap_SimulationMonopolyWorkUnit_DoWork}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_bases[] = {0};
static const char *swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_SimulationMonopolyWorkUnit = { "SimulationMonopolyWorkUnit", &SWIGTYPE_p_Mezzanine__Physics__SimulationMonopolyWorkUnit,_wrap_new_SimulationMonopolyWorkUnit, swig_delete_SimulationMonopolyWorkUnit, swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_methods, swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_attributes, swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_bases, swig_Mezzanine_Physics_SimulationMonopolyWorkUnit_base_names };

static int _wrap_new_WorldTriggerUpdateWorkUnit__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::WorldTriggerUpdateWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::WorldTriggerUpdateWorkUnit::WorldTriggerUpdateWorkUnit",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::WorldTriggerUpdateWorkUnit::WorldTriggerUpdateWorkUnit",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_WorldTriggerUpdateWorkUnit",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::WorldTriggerUpdateWorkUnit *)new Mezzanine::Physics::WorldTriggerUpdateWorkUnit(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_WorldTriggerUpdateWorkUnit(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_WorldTriggerUpdateWorkUnit__SWIG_1(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_WorldTriggerUpdateWorkUnit'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::WorldTriggerUpdateWorkUnit::WorldTriggerUpdateWorkUnit(Mezzanine::Physics::PhysicsManager *)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldTriggerUpdateWorkUnit_DoWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::WorldTriggerUpdateWorkUnit *arg1 = (Mezzanine::Physics::WorldTriggerUpdateWorkUnit *) 0 ;
  Mezzanine::Threading::DefaultThreadSpecificStorage::Type *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::WorldTriggerUpdateWorkUnit::DoWork",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::WorldTriggerUpdateWorkUnit::DoWork",1,"Mezzanine::Physics::WorldTriggerUpdateWorkUnit *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::WorldTriggerUpdateWorkUnit::DoWork",2,"Mezzanine::Threading::DefaultThreadSpecificStorage::Type &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit,0))){
    SWIG_fail_ptr("WorldTriggerUpdateWorkUnit_DoWork",1,SWIGTYPE_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,0))){
    SWIG_fail_ptr("WorldTriggerUpdateWorkUnit_DoWork",2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type);
  }
  
  (arg1)->DoWork(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_WorldTriggerUpdateWorkUnit(void *obj) {
Mezzanine::Physics::WorldTriggerUpdateWorkUnit *arg1 = (Mezzanine::Physics::WorldTriggerUpdateWorkUnit *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_methods[] = {
    {"DoWork", _wrap_WorldTriggerUpdateWorkUnit_DoWork}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_bases[] = {0};
static const char *swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_WorldTriggerUpdateWorkUnit = { "WorldTriggerUpdateWorkUnit", &SWIGTYPE_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit,_wrap_new_WorldTriggerUpdateWorkUnit, swig_delete_WorldTriggerUpdateWorkUnit, swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_methods, swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_attributes, swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_bases, swig_Mezzanine_Physics_WorldTriggerUpdateWorkUnit_base_names };

static int _wrap_new_DebugDrawWorkUnit__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::DebugDrawWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DebugDrawWorkUnit::DebugDrawWorkUnit",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DebugDrawWorkUnit::DebugDrawWorkUnit",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_DebugDrawWorkUnit",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::DebugDrawWorkUnit *)new Mezzanine::Physics::DebugDrawWorkUnit(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DebugDrawWorkUnit,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DebugDrawWorkUnit(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_DebugDrawWorkUnit__SWIG_1(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_DebugDrawWorkUnit'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::DebugDrawWorkUnit::DebugDrawWorkUnit(Mezzanine::Physics::PhysicsManager *)\n");
  lua_error(L);return 0;
}


static int _wrap_DebugDrawWorkUnit_DoWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DebugDrawWorkUnit *arg1 = (Mezzanine::Physics::DebugDrawWorkUnit *) 0 ;
  Mezzanine::Threading::DefaultThreadSpecificStorage::Type *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DebugDrawWorkUnit::DoWork",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DebugDrawWorkUnit::DoWork",1,"Mezzanine::Physics::DebugDrawWorkUnit *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DebugDrawWorkUnit::DoWork",2,"Mezzanine::Threading::DefaultThreadSpecificStorage::Type &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DebugDrawWorkUnit,0))){
    SWIG_fail_ptr("DebugDrawWorkUnit_DoWork",1,SWIGTYPE_p_Mezzanine__Physics__DebugDrawWorkUnit);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,0))){
    SWIG_fail_ptr("DebugDrawWorkUnit_DoWork",2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type);
  }
  
  (arg1)->DoWork(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DebugDrawWorkUnit(void *obj) {
Mezzanine::Physics::DebugDrawWorkUnit *arg1 = (Mezzanine::Physics::DebugDrawWorkUnit *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_DebugDrawWorkUnit_methods[] = {
    {"DoWork", _wrap_DebugDrawWorkUnit_DoWork}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_DebugDrawWorkUnit_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_DebugDrawWorkUnit_bases[] = {0};
static const char *swig_Mezzanine_Physics_DebugDrawWorkUnit_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_DebugDrawWorkUnit = { "DebugDrawWorkUnit", &SWIGTYPE_p_Mezzanine__Physics__DebugDrawWorkUnit,_wrap_new_DebugDrawWorkUnit, swig_delete_DebugDrawWorkUnit, swig_Mezzanine_Physics_DebugDrawWorkUnit_methods, swig_Mezzanine_Physics_DebugDrawWorkUnit_attributes, swig_Mezzanine_Physics_DebugDrawWorkUnit_bases, swig_Mezzanine_Physics_DebugDrawWorkUnit_base_names };

static int _wrap_new_PhysicsManager__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::PhysicsManager",0,0)
  result = (Mezzanine::Physics::PhysicsManager *)new Mezzanine::Physics::PhysicsManager();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PhysicsManager__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  ManagerConstructionInfo *arg1 = 0 ;
  Mezzanine::Physics::PhysicsManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::PhysicsManager",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::PhysicsManager",1,"ManagerConstructionInfo const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ManagerConstructionInfo,0))){
    SWIG_fail_ptr("new_PhysicsManager",1,SWIGTYPE_p_ManagerConstructionInfo);
  }
  
  result = (Mezzanine::Physics::PhysicsManager *)new Mezzanine::Physics::PhysicsManager((ManagerConstructionInfo const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PhysicsManager__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Physics::PhysicsManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::PhysicsManager",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::PhysicsManager",1,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_PhysicsManager",1,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::PhysicsManager *)new Mezzanine::Physics::PhysicsManager(*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PhysicsManager(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_PhysicsManager__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ManagerConstructionInfo, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_PhysicsManager__SWIG_1(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_PhysicsManager__SWIG_2(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_PhysicsManager'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::PhysicsManager()\n"
    "    Mezzanine::Physics::PhysicsManager::PhysicsManager(ManagerConstructionInfo const &)\n"
    "    Mezzanine::Physics::PhysicsManager::PhysicsManager(XML::Node &)\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_PauseSimulation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::PauseSimulation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::PauseSimulation",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::PauseSimulation",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_PauseSimulation",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->PauseSimulation(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_SimulationIsPaused(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::SimulationIsPaused",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SimulationIsPaused",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_SimulationIsPaused",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Boole)(arg1)->SimulationIsPaused();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetTimeMultiplier(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetTimeMultiplier",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetTimeMultiplier",1,"Mezzanine::Physics::PhysicsManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetTimeMultiplier",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::PhysicsManager const *)arg1)->GetTimeMultiplier();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_SetTimeMultiplier(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::SetTimeMultiplier",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetTimeMultiplier",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetTimeMultiplier",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_SetTimeMultiplier",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetTimeMultiplier((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_SetWorldGravity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::SetWorldGravity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetWorldGravity",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetWorldGravity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_SetWorldGravity",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("PhysicsManager_SetWorldGravity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetWorldGravity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetWorldGravity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetWorldGravity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldGravity",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetWorldGravity",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (arg1)->GetWorldGravity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_SetWorldSoftGravity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::SetWorldSoftGravity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetWorldSoftGravity",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetWorldSoftGravity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_SetWorldSoftGravity",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("PhysicsManager_SetWorldSoftGravity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetWorldSoftGravity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetWorldSoftGravity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetWorldSoftGravity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldSoftGravity",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetWorldSoftGravity",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (arg1)->GetWorldSoftGravity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateGhostProxy__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::GhostProxy *)(arg1)->CreateGhostProxy();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateGhostProxy__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Boole arg3 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",2,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",3,"Mezzanine::Boole const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  arg3 = (lua_toboolean(L, 3)!=0);
  result = (Mezzanine::Physics::GhostProxy *)(arg1)->CreateGhostProxy(arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateGhostProxy__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = (Mezzanine::Physics::GhostProxy *)(arg1)->CreateGhostProxy(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateGhostProxy__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  XML::Node *arg2 = 0 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateGhostProxy",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PhysicsManager_CreateGhostProxy",2,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::GhostProxy *)(arg1)->CreateGhostProxy((XML::Node const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateGhostProxy(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_PhysicsManager_CreateGhostProxy__SWIG_0(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_PhysicsManager_CreateGhostProxy__SWIG_2(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_PhysicsManager_CreateGhostProxy__SWIG_3(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isboolean(L,argv[2]);
        }
        if (_v) {
          return _wrap_PhysicsManager_CreateGhostProxy__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'PhysicsManager_CreateGhostProxy'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::CreateGhostProxy()\n"
    "    Mezzanine::Physics::PhysicsManager::CreateGhostProxy(Mezzanine::Physics::CollisionShape *,Mezzanine::Boole const)\n"
    "    Mezzanine::Physics::PhysicsManager::CreateGhostProxy(Mezzanine::Physics::CollisionShape *)\n"
    "    Mezzanine::Physics::PhysicsManager::CreateGhostProxy(XML::Node const &)\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_CreateRigidProxy__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  result = (Mezzanine::Physics::RigidProxy *)(arg1)->CreateRigidProxy(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateRigidProxy__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Physics::CollisionShape *arg3 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",2,"Mezzanine::Real const");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",3,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",4,"Mezzanine::Boole const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",3,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::RigidProxy *)(arg1)->CreateRigidProxy(arg2,arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateRigidProxy__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Physics::CollisionShape *arg3 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",2,"Mezzanine::Real const");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",3,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",3,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)(arg1)->CreateRigidProxy(arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateRigidProxy__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  XML::Node *arg2 = 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateRigidProxy",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PhysicsManager_CreateRigidProxy",2,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)(arg1)->CreateRigidProxy((XML::Node const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateRigidProxy(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_PhysicsManager_CreateRigidProxy__SWIG_3(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_PhysicsManager_CreateRigidProxy__SWIG_0(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_PhysicsManager_CreateRigidProxy__SWIG_2(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_PhysicsManager_CreateRigidProxy__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'PhysicsManager_CreateRigidProxy'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::CreateRigidProxy(Mezzanine::Real const)\n"
    "    Mezzanine::Physics::PhysicsManager::CreateRigidProxy(Mezzanine::Real const,Mezzanine::Physics::CollisionShape *,Mezzanine::Boole const)\n"
    "    Mezzanine::Physics::PhysicsManager::CreateRigidProxy(Mezzanine::Real const,Mezzanine::Physics::CollisionShape *)\n"
    "    Mezzanine::Physics::PhysicsManager::CreateRigidProxy(XML::Node const &)\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_CreateSoftProxy__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Physics::SoftProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateSoftProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateSoftProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateSoftProxy",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateSoftProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  result = (Mezzanine::Physics::SoftProxy *)(arg1)->CreateSoftProxy(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateSoftProxy__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  XML::Node *arg2 = 0 ;
  Mezzanine::Physics::SoftProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::CreateSoftProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateSoftProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::CreateSoftProxy",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_CreateSoftProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PhysicsManager_CreateSoftProxy",2,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::SoftProxy *)(arg1)->CreateSoftProxy((XML::Node const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_CreateSoftProxy(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_PhysicsManager_CreateSoftProxy__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_PhysicsManager_CreateSoftProxy__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'PhysicsManager_CreateSoftProxy'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::CreateSoftProxy(Mezzanine::Real const)\n"
    "    Mezzanine::Physics::PhysicsManager::CreateSoftProxy(XML::Node const &)\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_GetProxy(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::UInt32 arg2 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetProxy",1,"Mezzanine::Physics::PhysicsManager const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetProxy",2,"Mezzanine::UInt32 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::UInt32 const)lua_tonumber(L, 2);
  result = (Mezzanine::Physics::CollidableProxy *)((Mezzanine::Physics::PhysicsManager const *)arg1)->GetProxy(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetNumProxies(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::UInt32 result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetNumProxies",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetNumProxies",1,"Mezzanine::Physics::PhysicsManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetNumProxies",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::UInt32)((Mezzanine::Physics::PhysicsManager const *)arg1)->GetNumProxies();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_DestroyProxy(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::DestroyProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DestroyProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DestroyProxy",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_DestroyProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("PhysicsManager_DestroyProxy",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->DestroyProxy(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_DestroyAllProxies(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::DestroyAllProxies",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DestroyAllProxies",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_DestroyAllProxies",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->DestroyAllProxies();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_AddConstraint__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Constraint *arg2 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Boole arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::AddConstraint",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddConstraint",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddConstraint",2,"Mezzanine::Physics::Constraint *");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddConstraint",3,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_AddConstraint",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("PhysicsManager_AddConstraint",2,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg3 = (lua_toboolean(L, 3)!=0);
  (arg1)->AddConstraint(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_AddConstraint__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Constraint *arg2 = (Mezzanine::Physics::Constraint *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::AddConstraint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddConstraint",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddConstraint",2,"Mezzanine::Physics::Constraint *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_AddConstraint",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("PhysicsManager_AddConstraint",2,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  (arg1)->AddConstraint(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_AddConstraint(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Constraint, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_PhysicsManager_AddConstraint__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Constraint, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isboolean(L,argv[2]);
        }
        if (_v) {
          return _wrap_PhysicsManager_AddConstraint__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'PhysicsManager_AddConstraint'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::AddConstraint(Mezzanine::Physics::Constraint *,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::PhysicsManager::AddConstraint(Mezzanine::Physics::Constraint *)\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_GetConstraint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Constraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetConstraint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetConstraint",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetConstraint",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetConstraint",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Physics::Constraint *)(arg1)->GetConstraint((Mezzanine::Whole const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Constraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetNumConstraints(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetNumConstraints",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetNumConstraints",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetNumConstraints",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Whole)(arg1)->GetNumConstraints();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_RemoveConstraint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Constraint *arg2 = (Mezzanine::Physics::Constraint *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::RemoveConstraint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveConstraint",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveConstraint",2,"Mezzanine::Physics::Constraint *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveConstraint",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveConstraint",2,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  (arg1)->RemoveConstraint(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_DestroyAllConstraints(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::DestroyAllConstraints",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DestroyAllConstraints",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_DestroyAllConstraints",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->DestroyAllConstraints();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_AddWorldTrigger(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::WorldTrigger *arg2 = (Mezzanine::WorldTrigger *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::AddWorldTrigger",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddWorldTrigger",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::AddWorldTrigger",2,"Mezzanine::WorldTrigger *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_AddWorldTrigger",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__WorldTrigger,0))){
    SWIG_fail_ptr("PhysicsManager_AddWorldTrigger",2,SWIGTYPE_p_Mezzanine__WorldTrigger);
  }
  
  (arg1)->AddWorldTrigger(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetWorldTrigger__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::WorldTrigger *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetWorldTrigger",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldTrigger",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldTrigger",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetWorldTrigger",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  result = (Mezzanine::WorldTrigger *)(arg1)->GetWorldTrigger((Mezzanine::String const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldTrigger,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetWorldTrigger__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::WorldTrigger *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetWorldTrigger",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldTrigger",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldTrigger",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetWorldTrigger",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::WorldTrigger *)(arg1)->GetWorldTrigger((Mezzanine::Whole const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldTrigger,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetWorldTrigger(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_PhysicsManager_GetWorldTrigger__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        return _wrap_PhysicsManager_GetWorldTrigger__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'PhysicsManager_GetWorldTrigger'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::GetWorldTrigger(Mezzanine::String const &)\n"
    "    Mezzanine::Physics::PhysicsManager::GetWorldTrigger(Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_GetNumWorldTriggers(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetNumWorldTriggers",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetNumWorldTriggers",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetNumWorldTriggers",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Whole)(arg1)->GetNumWorldTriggers();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_RemoveWorldTrigger(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::WorldTrigger *arg2 = (Mezzanine::WorldTrigger *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::RemoveWorldTrigger",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveWorldTrigger",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveWorldTrigger",2,"Mezzanine::WorldTrigger *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveWorldTrigger",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__WorldTrigger,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveWorldTrigger",2,SWIGTYPE_p_Mezzanine__WorldTrigger);
  }
  
  (arg1)->RemoveWorldTrigger(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_DestroyAllWorldTriggers(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::DestroyAllWorldTriggers",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DestroyAllWorldTriggers",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_DestroyAllWorldTriggers",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->DestroyAllWorldTriggers();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetCollision(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  CollidablePair *arg2 = (CollidablePair *) 0 ;
  Mezzanine::Physics::Collision *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetCollision",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetCollision",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetCollision",2,"CollidablePair *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetCollision",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CollidablePair,0))){
    SWIG_fail_ptr("PhysicsManager_GetCollision",2,SWIGTYPE_p_CollidablePair);
  }
  
  result = (Mezzanine::Physics::Collision *)(arg1)->GetCollision(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Collision,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetNumCollisions(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetNumCollisions",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetNumCollisions",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetNumCollisions",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Whole)(arg1)->GetNumCollisions();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_RemoveCollision(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::Collision *arg2 = (Mezzanine::Physics::Collision *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::RemoveCollision",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveCollision",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveCollision",2,"Mezzanine::Physics::Collision *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveCollision",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveCollision",2,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  (arg1)->RemoveCollision(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_RemoveCollisionsContainingProxy(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::RemoveCollisionsContainingProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveCollisionsContainingProxy",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::RemoveCollisionsContainingProxy",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveCollisionsContainingProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("PhysicsManager_RemoveCollisionsContainingProxy",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->RemoveCollisionsContainingProxy(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_DestroyAllCollisions(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::DestroyAllCollisions",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DestroyAllCollisions",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_DestroyAllCollisions",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->DestroyAllCollisions();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_BeginCollision(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::PhysicsManager::CollisionIterator result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::BeginCollision",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::BeginCollision",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_BeginCollision",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (arg1)->BeginCollision();
  {
    Mezzanine::Physics::PhysicsManager::CollisionIterator * resultptr = new Mezzanine::Physics::PhysicsManager::CollisionIterator((const Mezzanine::Physics::PhysicsManager::CollisionIterator &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_EndCollision(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::PhysicsManager::CollisionIterator result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::EndCollision",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::EndCollision",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_EndCollision",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (arg1)->EndCollision();
  {
    Mezzanine::Physics::PhysicsManager::CollisionIterator * resultptr = new Mezzanine::Physics::PhysicsManager::CollisionIterator((const Mezzanine::Physics::PhysicsManager::CollisionIterator &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_SetDebugRenderingMode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Integer arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::SetDebugRenderingMode",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetDebugRenderingMode",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetDebugRenderingMode",2,"Mezzanine::Integer const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_SetDebugRenderingMode",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  arg2 = (Mezzanine::Integer const)lua_tonumber(L, 2);
  (arg1)->SetDebugRenderingMode(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetDebugRenderingMode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Integer result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetDebugRenderingMode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetDebugRenderingMode",1,"Mezzanine::Physics::PhysicsManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetDebugRenderingMode",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Integer)((Mezzanine::Physics::PhysicsManager const *)arg1)->GetDebugRenderingMode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_ResetPhysicsWorld__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  ManagerConstructionInfo *arg2 = (ManagerConstructionInfo *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld",1,"Mezzanine::Physics::PhysicsManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld",2,"ManagerConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_ResetPhysicsWorld",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ManagerConstructionInfo,0))){
    SWIG_fail_ptr("PhysicsManager_ResetPhysicsWorld",2,SWIGTYPE_p_ManagerConstructionInfo);
  }
  
  (arg1)->ResetPhysicsWorld(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_ResetPhysicsWorld__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_ResetPhysicsWorld",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->ResetPhysicsWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_ResetPhysicsWorld(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_PhysicsManager_ResetPhysicsWorld__SWIG_1(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ManagerConstructionInfo, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_PhysicsManager_ResetPhysicsWorld__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'PhysicsManager_ResetPhysicsWorld'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld(ManagerConstructionInfo *)\n"
    "    Mezzanine::Physics::PhysicsManager::ResetPhysicsWorld()\n");
  lua_error(L);return 0;
}


static int _wrap_PhysicsManager_ClearPhysicsMetaData(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::ClearPhysicsMetaData",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::ClearPhysicsMetaData",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_ClearPhysicsMetaData",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->ClearPhysicsMetaData();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_SetSimulationSubstepModifier(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::SetSimulationSubstepModifier",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetSimulationSubstepModifier",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::SetSimulationSubstepModifier",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_SetSimulationSubstepModifier",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSimulationSubstepModifier((Mezzanine::Whole const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_Pause(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::UInt32 arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::Pause",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::Pause",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::Pause",2,"Mezzanine::UInt32 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_Pause",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::UInt32 const)lua_tonumber(L, 2);
  (arg1)->Pause(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_MainLoopInitialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::MainLoopInitialize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::MainLoopInitialize",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_MainLoopInitialize",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->MainLoopInitialize();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_Initialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::Initialize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::Initialize",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_Initialize",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->Initialize();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_Deinitialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::Deinitialize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::Deinitialize",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_Deinitialize",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  (arg1)->Deinitialize();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_DoPerFrameWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Threading::DefaultThreadSpecificStorage::Type *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::DoPerFrameWork",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DoPerFrameWork",1,"Mezzanine::Physics::PhysicsManager *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::DoPerFrameWork",2,"Mezzanine::Threading::DefaultThreadSpecificStorage::Type &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_DoPerFrameWork",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,0))){
    SWIG_fail_ptr("PhysicsManager_DoPerFrameWork",2,SWIGTYPE_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type);
  }
  
  (arg1)->DoPerFrameWork(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetSimulationWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Threading::DefaultWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetSimulationWork",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetSimulationWork",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetSimulationWork",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Threading::DefaultWorkUnit *)(arg1)->GetSimulationWork();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Threading__DefaultWorkUnit,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetWorldTriggerUpdateWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::WorldTriggerUpdateWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetWorldTriggerUpdateWork",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetWorldTriggerUpdateWork",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetWorldTriggerUpdateWork",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::WorldTriggerUpdateWorkUnit *)(arg1)->GetWorldTriggerUpdateWork();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetDebugDrawWork(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::DebugDrawWorkUnit *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetDebugDrawWork",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetDebugDrawWork",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetDebugDrawWork",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::DebugDrawWorkUnit *)(arg1)->GetDebugDrawWork();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DebugDrawWorkUnit,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetInterfaceType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  ManagerBase::ManagerType result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetInterfaceType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetInterfaceType",1,"Mezzanine::Physics::PhysicsManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetInterfaceType",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = ((Mezzanine::Physics::PhysicsManager const *)arg1)->GetInterfaceType();
  {
    ManagerBase::ManagerType * resultptr = new ManagerBase::ManagerType((const ManagerBase::ManagerType &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ManagerBase__ManagerType,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PhysicsManager_GetImplementationTypeName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::PhysicsManager::GetImplementationTypeName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PhysicsManager::GetImplementationTypeName",1,"Mezzanine::Physics::PhysicsManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("PhysicsManager_GetImplementationTypeName",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = ((Mezzanine::Physics::PhysicsManager const *)arg1)->GetImplementationTypeName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_PhysicsManager(void *obj) {
Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_PhysicsManager_methods[] = {
    {"PauseSimulation", _wrap_PhysicsManager_PauseSimulation}, 
    {"SimulationIsPaused", _wrap_PhysicsManager_SimulationIsPaused}, 
    {"GetTimeMultiplier", _wrap_PhysicsManager_GetTimeMultiplier}, 
    {"SetTimeMultiplier", _wrap_PhysicsManager_SetTimeMultiplier}, 
    {"SetWorldGravity", _wrap_PhysicsManager_SetWorldGravity}, 
    {"GetWorldGravity", _wrap_PhysicsManager_GetWorldGravity}, 
    {"SetWorldSoftGravity", _wrap_PhysicsManager_SetWorldSoftGravity}, 
    {"GetWorldSoftGravity", _wrap_PhysicsManager_GetWorldSoftGravity}, 
    {"CreateGhostProxy", _wrap_PhysicsManager_CreateGhostProxy}, 
    {"CreateRigidProxy", _wrap_PhysicsManager_CreateRigidProxy}, 
    {"CreateSoftProxy", _wrap_PhysicsManager_CreateSoftProxy}, 
    {"GetProxy", _wrap_PhysicsManager_GetProxy}, 
    {"GetNumProxies", _wrap_PhysicsManager_GetNumProxies}, 
    {"DestroyProxy", _wrap_PhysicsManager_DestroyProxy}, 
    {"DestroyAllProxies", _wrap_PhysicsManager_DestroyAllProxies}, 
    {"AddConstraint", _wrap_PhysicsManager_AddConstraint}, 
    {"GetConstraint", _wrap_PhysicsManager_GetConstraint}, 
    {"GetNumConstraints", _wrap_PhysicsManager_GetNumConstraints}, 
    {"RemoveConstraint", _wrap_PhysicsManager_RemoveConstraint}, 
    {"DestroyAllConstraints", _wrap_PhysicsManager_DestroyAllConstraints}, 
    {"AddWorldTrigger", _wrap_PhysicsManager_AddWorldTrigger}, 
    {"GetWorldTrigger", _wrap_PhysicsManager_GetWorldTrigger}, 
    {"GetNumWorldTriggers", _wrap_PhysicsManager_GetNumWorldTriggers}, 
    {"RemoveWorldTrigger", _wrap_PhysicsManager_RemoveWorldTrigger}, 
    {"DestroyAllWorldTriggers", _wrap_PhysicsManager_DestroyAllWorldTriggers}, 
    {"GetCollision", _wrap_PhysicsManager_GetCollision}, 
    {"GetNumCollisions", _wrap_PhysicsManager_GetNumCollisions}, 
    {"RemoveCollision", _wrap_PhysicsManager_RemoveCollision}, 
    {"RemoveCollisionsContainingProxy", _wrap_PhysicsManager_RemoveCollisionsContainingProxy}, 
    {"DestroyAllCollisions", _wrap_PhysicsManager_DestroyAllCollisions}, 
    {"BeginCollision", _wrap_PhysicsManager_BeginCollision}, 
    {"EndCollision", _wrap_PhysicsManager_EndCollision}, 
    {"SetDebugRenderingMode", _wrap_PhysicsManager_SetDebugRenderingMode}, 
    {"GetDebugRenderingMode", _wrap_PhysicsManager_GetDebugRenderingMode}, 
    {"ResetPhysicsWorld", _wrap_PhysicsManager_ResetPhysicsWorld}, 
    {"ClearPhysicsMetaData", _wrap_PhysicsManager_ClearPhysicsMetaData}, 
    {"SetSimulationSubstepModifier", _wrap_PhysicsManager_SetSimulationSubstepModifier}, 
    {"Pause", _wrap_PhysicsManager_Pause}, 
    {"MainLoopInitialize", _wrap_PhysicsManager_MainLoopInitialize}, 
    {"Initialize", _wrap_PhysicsManager_Initialize}, 
    {"Deinitialize", _wrap_PhysicsManager_Deinitialize}, 
    {"DoPerFrameWork", _wrap_PhysicsManager_DoPerFrameWork}, 
    {"GetSimulationWork", _wrap_PhysicsManager_GetSimulationWork}, 
    {"GetWorldTriggerUpdateWork", _wrap_PhysicsManager_GetWorldTriggerUpdateWork}, 
    {"GetDebugDrawWork", _wrap_PhysicsManager_GetDebugDrawWork}, 
    {"GetInterfaceType", _wrap_PhysicsManager_GetInterfaceType}, 
    {"GetImplementationTypeName", _wrap_PhysicsManager_GetImplementationTypeName}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_PhysicsManager_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_PhysicsManager_bases[] = {0};
static const char *swig_Mezzanine_Physics_PhysicsManager_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_PhysicsManager = { "PhysicsManager", &SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,_wrap_new_PhysicsManager, swig_delete_PhysicsManager, swig_Mezzanine_Physics_PhysicsManager_methods, swig_Mezzanine_Physics_PhysicsManager_attributes, swig_Mezzanine_Physics_PhysicsManager_bases, swig_Mezzanine_Physics_PhysicsManager_base_names };

static int _wrap_new_DefaultPhysicsManagerFactory(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultPhysicsManagerFactory *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultPhysicsManagerFactory::DefaultPhysicsManagerFactory",0,0)
  result = (Mezzanine::Physics::DefaultPhysicsManagerFactory *)new Mezzanine::Physics::DefaultPhysicsManagerFactory();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultPhysicsManagerFactory_GetManagerTypeName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultPhysicsManagerFactory *arg1 = (Mezzanine::Physics::DefaultPhysicsManagerFactory *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultPhysicsManagerFactory::GetManagerTypeName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::GetManagerTypeName",1,"Mezzanine::Physics::DefaultPhysicsManagerFactory const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_GetManagerTypeName",1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory);
  }
  
  result = ((Mezzanine::Physics::DefaultPhysicsManagerFactory const *)arg1)->GetManagerTypeName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultPhysicsManagerFactory_CreateManager__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultPhysicsManagerFactory *arg1 = (Mezzanine::Physics::DefaultPhysicsManagerFactory *) 0 ;
  Mezzanine::NameValuePairList *arg2 = 0 ;
  ManagerBase *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager",1,"Mezzanine::Physics::DefaultPhysicsManagerFactory *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager",2,"Mezzanine::NameValuePairList &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_CreateManager",1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_CreateManager",2,SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t);
  }
  
  result = (ManagerBase *)(arg1)->CreateManager(*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_ManagerBase,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultPhysicsManagerFactory_CreateManager__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultPhysicsManagerFactory *arg1 = (Mezzanine::Physics::DefaultPhysicsManagerFactory *) 0 ;
  XML::Node *arg2 = 0 ;
  ManagerBase *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager",1,"Mezzanine::Physics::DefaultPhysicsManagerFactory *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_CreateManager",1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_CreateManager",2,SWIGTYPE_p_XML__Node);
  }
  
  result = (ManagerBase *)(arg1)->CreateManager(*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_ManagerBase,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultPhysicsManagerFactory_CreateManager(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_DefaultPhysicsManagerFactory_CreateManager__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_DefaultPhysicsManagerFactory_CreateManager__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'DefaultPhysicsManagerFactory_CreateManager'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager(Mezzanine::NameValuePairList &)\n"
    "    Mezzanine::Physics::DefaultPhysicsManagerFactory::CreateManager(XML::Node &)\n");
  lua_error(L);return 0;
}


static int _wrap_DefaultPhysicsManagerFactory_DestroyManager(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultPhysicsManagerFactory *arg1 = (Mezzanine::Physics::DefaultPhysicsManagerFactory *) 0 ;
  ManagerBase *arg2 = (ManagerBase *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultPhysicsManagerFactory::DestroyManager",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::DestroyManager",1,"Mezzanine::Physics::DefaultPhysicsManagerFactory *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::DefaultPhysicsManagerFactory::DestroyManager",2,"ManagerBase *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_DestroyManager",1,SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ManagerBase,0))){
    SWIG_fail_ptr("DefaultPhysicsManagerFactory_DestroyManager",2,SWIGTYPE_p_ManagerBase);
  }
  
  (arg1)->DestroyManager(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DefaultPhysicsManagerFactory(void *obj) {
Mezzanine::Physics::DefaultPhysicsManagerFactory *arg1 = (Mezzanine::Physics::DefaultPhysicsManagerFactory *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_methods[] = {
    {"GetManagerTypeName", _wrap_DefaultPhysicsManagerFactory_GetManagerTypeName}, 
    {"CreateManager", _wrap_DefaultPhysicsManagerFactory_CreateManager}, 
    {"DestroyManager", _wrap_DefaultPhysicsManagerFactory_DestroyManager}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_bases[] = {0};
static const char *swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_DefaultPhysicsManagerFactory = { "DefaultPhysicsManagerFactory", &SWIGTYPE_p_Mezzanine__Physics__DefaultPhysicsManagerFactory,_wrap_new_DefaultPhysicsManagerFactory, swig_delete_DefaultPhysicsManagerFactory, swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_methods, swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_attributes, swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_bases, swig_Mezzanine_Physics_DefaultPhysicsManagerFactory_base_names };

static int _wrap_CollisionShape_GetName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::String *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::GetName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::GetName",1,"Mezzanine::Physics::CollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_GetName",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = (Mezzanine::String *) &((Mezzanine::Physics::CollisionShape const *)arg1)->GetName();
  lua_pushlstring(L,result->data(),result->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::GetType",1,"Mezzanine::Physics::CollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::CollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_SetMargin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::SetMargin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::SetMargin",1,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::SetMargin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_SetMargin",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetMargin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_GetMargin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::GetMargin",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::GetMargin",1,"Mezzanine::Physics::CollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_GetMargin",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CollisionShape const *)arg1)->GetMargin();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_SetScaling(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::SetScaling",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::SetScaling",1,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::SetScaling",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_SetScaling",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollisionShape_SetScaling",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetScaling((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_GetScaling(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::GetScaling",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::GetScaling",1,"Mezzanine::Physics::CollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_GetScaling",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = ((Mezzanine::Physics::CollisionShape const *)arg1)->GetScaling();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::ProtoSerialize",1,"Mezzanine::Physics::CollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::CollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::CollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape__SetShapeName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::_SetShapeName",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::_SetShapeName",1,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::_SetShapeName",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape__SetShapeName",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  (arg1)->_SetShapeName((Mezzanine::String const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShape__GetInternalShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  btCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShape::_GetInternalShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShape::_GetInternalShape",1,"Mezzanine::Physics::CollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShape__GetInternalShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  result = (btCollisionShape *)((Mezzanine::Physics::CollisionShape const *)arg1)->_GetInternalShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CollisionShape(void *obj) {
Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CollisionShape_methods[] = {
    {"GetName", _wrap_CollisionShape_GetName}, 
    {"GetType", _wrap_CollisionShape_GetType}, 
    {"SetMargin", _wrap_CollisionShape_SetMargin}, 
    {"GetMargin", _wrap_CollisionShape_GetMargin}, 
    {"SetScaling", _wrap_CollisionShape_SetScaling}, 
    {"GetScaling", _wrap_CollisionShape_GetScaling}, 
    {"ProtoSerialize", _wrap_CollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_CollisionShape_ProtoDeSerialize}, 
    {"_SetShapeName", _wrap_CollisionShape__SetShapeName}, 
    {"_GetInternalShape", _wrap_CollisionShape__GetInternalShape}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CollisionShape_bases[] = {0};
static const char *swig_Mezzanine_Physics_CollisionShape_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CollisionShape = { "CollisionShape", &SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0, swig_delete_CollisionShape, swig_Mezzanine_Physics_CollisionShape_methods, swig_Mezzanine_Physics_CollisionShape_attributes, swig_Mezzanine_Physics_CollisionShape_bases, swig_Mezzanine_Physics_CollisionShape_base_names };

static int _wrap_CreateShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape::ShapeType arg1 ;
  Mezzanine::String *arg2 = 0 ;
  btCollisionShape *arg3 = (btCollisionShape *) 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CreateShape",3,3)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::CreateShape",1,"Mezzanine::Physics::CollisionShape::ShapeType");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CreateShape",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CreateShape",3,"btCollisionShape *");
  arg1 = (Mezzanine::Physics::CollisionShape::ShapeType)(int)lua_tonumber(L, 1);
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_btCollisionShape,0))){
    SWIG_fail_ptr("CreateShape",3,SWIGTYPE_p_btCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape *)Mezzanine::Physics::CreateShape(arg1,(std::string const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CreateShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CreateShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::CreateShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CreateShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::CollisionShape *)Mezzanine::Physics::CreateShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CreateShape(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_CreateShape__SWIG_1(L);
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_btCollisionShape, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_CreateShape__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CreateShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CreateShape(Mezzanine::Physics::CollisionShape::ShapeType,Mezzanine::String const &,btCollisionShape *)\n"
    "    Mezzanine::Physics::CreateShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_InternalShapeTypeToShapeType(lua_State* L) {
  int SWIG_arg = 0;
  int arg1 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::InternalShapeTypeToShapeType",1,1)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::InternalShapeTypeToShapeType",1,"int");
  arg1 = (int)lua_tonumber(L, 1);
  result = (Mezzanine::Physics::CollisionShape::ShapeType)Mezzanine::Physics::InternalShapeTypeToShapeType(arg1);
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ShapeTypeToString(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape::ShapeType arg1 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::ShapeTypeToString",1,1)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::ShapeTypeToString",1,"Mezzanine::Physics::CollisionShape::ShapeType");
  arg1 = (Mezzanine::Physics::CollisionShape::ShapeType)(int)lua_tonumber(L, 1);
  result = Mezzanine::Physics::ShapeTypeToString(arg1);
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StringToShapeType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::StringToShapeType",1,1)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::StringToShapeType",1,"Mezzanine::String const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  result = (Mezzanine::Physics::CollisionShape::ShapeType)Mezzanine::Physics::StringToShapeType((std::string const &)*arg1);
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeDeSerializer_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeDeSerializer *arg1 = (Mezzanine::Physics::CollisionShapeDeSerializer *) 0 ;
  XML::Node *arg2 = 0 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeDeSerializer::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::ProtoDeSerialize",1,"Mezzanine::Physics::CollisionShapeDeSerializer *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::CollisionShape *)(arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeDeSerializer_DeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeDeSerializer *arg1 = (Mezzanine::Physics::CollisionShapeDeSerializer *) 0 ;
  std::istream *arg2 = 0 ;
  std::istream *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeDeSerializer::DeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::DeSerialize",1,"Mezzanine::Physics::CollisionShapeDeSerializer *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::DeSerialize",2,"std::istream &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_DeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__istream,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_DeSerialize",2,SWIGTYPE_p_std__istream);
  }
  
  result = (std::istream *) &(arg1)->DeSerialize(*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__istream,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeDeSerializer_DeSerializeAndRetrieve(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeDeSerializer *arg1 = (Mezzanine::Physics::CollisionShapeDeSerializer *) 0 ;
  std::istream *arg2 = 0 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeDeSerializer::DeSerializeAndRetrieve",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::DeSerializeAndRetrieve",1,"Mezzanine::Physics::CollisionShapeDeSerializer *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::DeSerializeAndRetrieve",2,"std::istream &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_DeSerializeAndRetrieve",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__istream,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_DeSerializeAndRetrieve",2,SWIGTYPE_p_std__istream);
  }
  
  result = (Mezzanine::Physics::CollisionShape *)(arg1)->DeSerializeAndRetrieve(*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeDeSerializer_ContainerName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeDeSerializer *arg1 = (Mezzanine::Physics::CollisionShapeDeSerializer *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeDeSerializer::ContainerName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeDeSerializer::ContainerName",1,"Mezzanine::Physics::CollisionShapeDeSerializer const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer,0))){
    SWIG_fail_ptr("CollisionShapeDeSerializer_ContainerName",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer);
  }
  
  result = ((Mezzanine::Physics::CollisionShapeDeSerializer const *)arg1)->ContainerName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CollisionShapeDeSerializer(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeDeSerializer *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeDeSerializer::CollisionShapeDeSerializer",0,0)
  result = (Mezzanine::Physics::CollisionShapeDeSerializer *)new Mezzanine::Physics::CollisionShapeDeSerializer();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CollisionShapeDeSerializer(void *obj) {
Mezzanine::Physics::CollisionShapeDeSerializer *arg1 = (Mezzanine::Physics::CollisionShapeDeSerializer *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CollisionShapeDeSerializer_methods[] = {
    {"ProtoDeSerialize", _wrap_CollisionShapeDeSerializer_ProtoDeSerialize}, 
    {"DeSerialize", _wrap_CollisionShapeDeSerializer_DeSerialize}, 
    {"DeSerializeAndRetrieve", _wrap_CollisionShapeDeSerializer_DeSerializeAndRetrieve}, 
    {"ContainerName", _wrap_CollisionShapeDeSerializer_ContainerName}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CollisionShapeDeSerializer_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CollisionShapeDeSerializer_bases[] = {0};
static const char *swig_Mezzanine_Physics_CollisionShapeDeSerializer_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CollisionShapeDeSerializer = { "CollisionShapeDeSerializer", &SWIGTYPE_p_Mezzanine__Physics__CollisionShapeDeSerializer,_wrap_new_CollisionShapeDeSerializer, swig_delete_CollisionShapeDeSerializer, swig_Mezzanine_Physics_CollisionShapeDeSerializer_methods, swig_Mezzanine_Physics_CollisionShapeDeSerializer_attributes, swig_Mezzanine_Physics_CollisionShapeDeSerializer_bases, swig_Mezzanine_Physics_CollisionShapeDeSerializer_base_names };

static int _wrap_new_SingletonCollisionShapeManager(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Singleton< CollisionShapeManager > *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Singleton< CollisionShapeManager >::Singleton",0,0)
  result = (Mezzanine::Singleton< CollisionShapeManager > *)new Mezzanine::Singleton< CollisionShapeManager >();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SingletonT_CollisionShapeManager_t,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SingletonCollisionShapeManager_GetSingletonPtr(lua_State* L) {
  int SWIG_arg = 0;
  CollisionShapeManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Singleton< CollisionShapeManager >::GetSingletonPtr",0,0)
  result = (CollisionShapeManager *)Mezzanine::Singleton< CollisionShapeManager >::SWIGTEMPLATEDISAMBIGUATOR GetSingletonPtr();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_CollisionShapeManager,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SingletonCollisionShapeManager_SingletonValid(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Singleton< CollisionShapeManager >::SingletonValid",0,0)
  result = (Mezzanine::Boole)Mezzanine::Singleton< CollisionShapeManager >::SWIGTEMPLATEDISAMBIGUATOR SingletonValid();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SingletonCollisionShapeManager(void *obj) {
Mezzanine::Singleton< CollisionShapeManager > *arg1 = (Mezzanine::Singleton< CollisionShapeManager > *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__methods[] = {
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__bases[] = {0};
static const char *swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg_ = { "SingletonCollisionShapeManager", &SWIGTYPE_p_Mezzanine__SingletonT_CollisionShapeManager_t,_wrap_new_SingletonCollisionShapeManager, swig_delete_SingletonCollisionShapeManager, swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__methods, swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__attributes, swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__bases, swig_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg__base_names };

static int _wrap_new_CollisionShapeManager__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::CollisionShapeManager",0,0)
  result = (Mezzanine::Physics::CollisionShapeManager *)new Mezzanine::Physics::CollisionShapeManager();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CollisionShapeManager__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Physics::CollisionShapeManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::CollisionShapeManager",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::CollisionShapeManager",1,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_CollisionShapeManager",1,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::CollisionShapeManager *)new Mezzanine::Physics::CollisionShapeManager(*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CollisionShapeManager(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_CollisionShapeManager__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_CollisionShapeManager__SWIG_1(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_CollisionShapeManager'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::CollisionShapeManager()\n"
    "    Mezzanine::Physics::CollisionShapeManager::CollisionShapeManager(XML::Node &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_StoreShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::StoreShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::StoreShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::StoreShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_StoreShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShapeManager_StoreShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->StoreShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GetShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GetShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GetShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GetShape",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GetShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  result = (Mezzanine::Physics::CollisionShape *)(arg1)->GetShape((Mezzanine::String const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GetNumStoredShapes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GetNumStoredShapes",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GetNumStoredShapes",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GetNumStoredShapes",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  result = (Mezzanine::Whole)(arg1)->GetNumStoredShapes();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_RemoveShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::RemoveShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::RemoveShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::RemoveShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_RemoveShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShapeManager_RemoveShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->RemoveShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_RemoveShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::RemoveShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::RemoveShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::RemoveShape",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_RemoveShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  (arg1)->RemoveShape((Mezzanine::String const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_RemoveShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollisionShapeManager_RemoveShape__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        return _wrap_CollisionShapeManager_RemoveShape__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollisionShapeManager_RemoveShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::RemoveShape(Mezzanine::Physics::CollisionShape *)\n"
    "    Mezzanine::Physics::CollisionShapeManager::RemoveShape(Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_RemoveAllShapes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::RemoveAllShapes",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::RemoveAllShapes",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_RemoveAllShapes",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  (arg1)->RemoveAllShapes();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_DestroyShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::DestroyShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::DestroyShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::DestroyShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_DestroyShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShapeManager_DestroyShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->DestroyShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_DestroyShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::DestroyShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::DestroyShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::DestroyShape",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_DestroyShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  (arg1)->DestroyShape((Mezzanine::String const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_DestroyShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollisionShapeManager_DestroyShape__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        return _wrap_CollisionShapeManager_DestroyShape__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollisionShapeManager_DestroyShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::DestroyShape(Mezzanine::Physics::CollisionShape *)\n"
    "    Mezzanine::Physics::CollisionShapeManager::DestroyShape(Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_DestroyAllShapes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::DestroyAllShapes",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::DestroyAllShapes",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_DestroyAllShapes",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  (arg1)->DestroyAllShapes();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_BeginCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::BeginCollisionShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::BeginCollisionShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_BeginCollisionShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  result = (arg1)->BeginCollisionShape();
  {
    Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator * resultptr = new Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator((const Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_EndCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::EndCollisionShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::EndCollisionShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_EndCollisionShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  result = (arg1)->EndCollisionShape();
  {
    Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator * resultptr = new Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator((const Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",3,"Mezzanine::Graphics::Mesh *");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",4,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateConvexHull",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateConvexHull",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)(arg1)->GenerateConvexHull((Mezzanine::String const &)*arg2,arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",3,"Mezzanine::Graphics::Mesh *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateConvexHull",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateConvexHull",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)(arg1)->GenerateConvexHull((Mezzanine::String const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",4,"Mezzanine::String const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateConvexHull",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)(arg1)->GenerateConvexHull((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull",4,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateConvexHull",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)(arg1)->GenerateConvexHull((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateConvexHull(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_0(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_3(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_CollisionShapeManager_GenerateConvexHull__SWIG_2(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollisionShapeManager_GenerateConvexHull'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull(Mezzanine::String const &,Mezzanine::Graphics::Mesh *,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull(Mezzanine::String const &,Mezzanine::Graphics::Mesh *)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateConvexHull(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::DynamicMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",3,"Mezzanine::Graphics::Mesh *");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",4,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateDynamicTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateDynamicTriMesh",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::DynamicMeshCollisionShape *)(arg1)->GenerateDynamicTriMesh((Mezzanine::String const &)*arg2,arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::DynamicMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",3,"Mezzanine::Graphics::Mesh *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateDynamicTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateDynamicTriMesh",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  result = (Mezzanine::Physics::DynamicMeshCollisionShape *)(arg1)->GenerateDynamicTriMesh((Mezzanine::String const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::DynamicMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",4,"Mezzanine::String const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateDynamicTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::DynamicMeshCollisionShape *)(arg1)->GenerateDynamicTriMesh((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::DynamicMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh",4,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateDynamicTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  result = (Mezzanine::Physics::DynamicMeshCollisionShape *)(arg1)->GenerateDynamicTriMesh((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateDynamicTriMesh(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_0(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_3(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_CollisionShapeManager_GenerateDynamicTriMesh__SWIG_2(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollisionShapeManager_GenerateDynamicTriMesh'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh(Mezzanine::String const &,Mezzanine::Graphics::Mesh *,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh(Mezzanine::String const &,Mezzanine::Graphics::Mesh *)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateDynamicTriMesh(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::StaticMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",3,"Mezzanine::Graphics::Mesh *");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",4,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateStaticTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateStaticTriMesh",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::StaticMeshCollisionShape *)(arg1)->GenerateStaticTriMesh((Mezzanine::String const &)*arg2,arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::StaticMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",3,"Mezzanine::Graphics::Mesh *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateStaticTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateStaticTriMesh",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  result = (Mezzanine::Physics::StaticMeshCollisionShape *)(arg1)->GenerateStaticTriMesh((Mezzanine::String const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::StaticMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",4,"Mezzanine::String const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateStaticTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::StaticMeshCollisionShape *)(arg1)->GenerateStaticTriMesh((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::StaticMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh",4,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GenerateStaticTriMesh",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  result = (Mezzanine::Physics::StaticMeshCollisionShape *)(arg1)->GenerateStaticTriMesh((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GenerateStaticTriMesh(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_0(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_3(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_CollisionShapeManager_GenerateStaticTriMesh__SWIG_2(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollisionShapeManager_GenerateStaticTriMesh'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh(Mezzanine::String const &,Mezzanine::Graphics::Mesh *,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh(Mezzanine::String const &,Mezzanine::Graphics::Mesh *)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::GenerateStaticTriMesh(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::Whole arg4 ;
  Mezzanine::Real arg5 ;
  Mezzanine::Real arg6 ;
  Mezzanine::Boole arg7 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::CompoundCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",3,"Mezzanine::Graphics::Mesh *");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",4,"Mezzanine::Whole");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",5,"Mezzanine::Real");
  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",6,"Mezzanine::Real");
  if(!lua_isboolean(L,7)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",7,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_PerformConvexDecomposition",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_PerformConvexDecomposition",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  arg4 = (Mezzanine::Whole)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real)lua_tonumber(L, 5);
  arg6 = (Mezzanine::Real)lua_tonumber(L, 6);
  arg7 = (lua_toboolean(L, 7)!=0);
  result = (Mezzanine::Physics::CompoundCollisionShape *)(arg1)->PerformConvexDecomposition((Mezzanine::String const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Graphics::Mesh *arg3 = (Mezzanine::Graphics::Mesh *) 0 ;
  Mezzanine::Whole arg4 ;
  Mezzanine::Real arg5 ;
  Mezzanine::Real arg6 ;
  Mezzanine::String temp2 ;
  Mezzanine::Physics::CompoundCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",6,6)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",3,"Mezzanine::Graphics::Mesh *");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",4,"Mezzanine::Whole");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",5,"Mezzanine::Real");
  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",6,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_PerformConvexDecomposition",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Graphics__Mesh,0))){
    SWIG_fail_ptr("CollisionShapeManager_PerformConvexDecomposition",3,SWIGTYPE_p_Mezzanine__Graphics__Mesh);
  }
  
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  arg4 = (Mezzanine::Whole)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real)lua_tonumber(L, 5);
  arg6 = (Mezzanine::Real)lua_tonumber(L, 6);
  result = (Mezzanine::Physics::CompoundCollisionShape *)(arg1)->PerformConvexDecomposition((Mezzanine::String const &)*arg2,arg3,arg4,arg5,arg6);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole arg5 ;
  Mezzanine::Real arg6 ;
  Mezzanine::Real arg7 ;
  Mezzanine::Boole arg8 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::CompoundCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",8,8)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",5,"Mezzanine::Whole");
  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",6,"Mezzanine::Real");
  if(!lua_isnumber(L,7)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",7,"Mezzanine::Real");
  if(!lua_isboolean(L,8)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",8,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_PerformConvexDecomposition",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  arg5 = (Mezzanine::Whole)lua_tonumber(L, 5);
  arg6 = (Mezzanine::Real)lua_tonumber(L, 6);
  arg7 = (Mezzanine::Real)lua_tonumber(L, 7);
  arg8 = (lua_toboolean(L, 8)!=0);
  result = (Mezzanine::Physics::CompoundCollisionShape *)(arg1)->PerformConvexDecomposition((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,arg5,arg6,arg7,arg8);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole arg5 ;
  Mezzanine::Real arg6 ;
  Mezzanine::Real arg7 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Physics::CompoundCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",5,"Mezzanine::Whole");
  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",6,"Mezzanine::Real");
  if(!lua_isnumber(L,7)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition",7,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_PerformConvexDecomposition",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  arg5 = (Mezzanine::Whole)lua_tonumber(L, 5);
  arg6 = (Mezzanine::Real)lua_tonumber(L, 6);
  arg7 = (Mezzanine::Real)lua_tonumber(L, 7);
  result = (Mezzanine::Physics::CompoundCollisionShape *)(arg1)->PerformConvexDecomposition((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,arg5,arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_PerformConvexDecomposition(lua_State* L) {
  int argc;
  int argv[9]={
    1,2,3,4,5,6,7,8,9
  };
  
  argc = lua_gettop(L);
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              {
                _v = lua_isnumber(L,argv[5]);
              }
              if (_v) {
                return _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_1(L);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Graphics__Mesh, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              {
                _v = lua_isnumber(L,argv[5]);
              }
              if (_v) {
                {
                  _v = lua_isboolean(L,argv[6]);
                }
                if (_v) {
                  return _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_0(L);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              {
                _v = lua_isnumber(L,argv[5]);
              }
              if (_v) {
                {
                  _v = lua_isnumber(L,argv[6]);
                }
                if (_v) {
                  return _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_3(L);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              {
                _v = lua_isnumber(L,argv[5]);
              }
              if (_v) {
                {
                  _v = lua_isnumber(L,argv[6]);
                }
                if (_v) {
                  {
                    _v = lua_isboolean(L,argv[7]);
                  }
                  if (_v) {
                    return _wrap_CollisionShapeManager_PerformConvexDecomposition__SWIG_2(L);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollisionShapeManager_PerformConvexDecomposition'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition(Mezzanine::String const &,Mezzanine::Graphics::Mesh *,Mezzanine::Whole,Mezzanine::Real,Mezzanine::Real,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition(Mezzanine::String const &,Mezzanine::Graphics::Mesh *,Mezzanine::Whole,Mezzanine::Real,Mezzanine::Real)\n"
    "    Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole,Mezzanine::Real,Mezzanine::Real,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollisionShapeManager::PerformConvexDecomposition(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole,Mezzanine::Real,Mezzanine::Real)\n");
  lua_error(L);return 0;
}


static int _wrap_CollisionShapeManager_LoadAllShapesFromXMLFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromXMLFile",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromXMLFile",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromXMLFile",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromXMLFile",3,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_LoadAllShapesFromXMLFile",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  (arg1)->LoadAllShapesFromXMLFile((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_SaveAllStoredShapesToXMLFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::SaveAllStoredShapesToXMLFile",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveAllStoredShapesToXMLFile",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveAllStoredShapesToXMLFile",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_SaveAllStoredShapesToXMLFile",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  (arg1)->SaveAllStoredShapesToXMLFile((Mezzanine::String const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_SaveShapesToXMLFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Physics::CollisionShapeManager::ShapeVector *arg3 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::SaveShapesToXMLFile",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveShapesToXMLFile",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveShapesToXMLFile",2,"Mezzanine::String const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveShapesToXMLFile",3,"Mezzanine::Physics::CollisionShapeManager::ShapeVector &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_SaveShapesToXMLFile",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t,0))){
    SWIG_fail_ptr("CollisionShapeManager_SaveShapesToXMLFile",3,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t);
  }
  
  (arg1)->SaveShapesToXMLFile((Mezzanine::String const &)*arg2,*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_LoadAllShapesFromBinaryFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromBinaryFile",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromBinaryFile",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromBinaryFile",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::LoadAllShapesFromBinaryFile",3,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_LoadAllShapesFromBinaryFile",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  (arg1)->LoadAllShapesFromBinaryFile((Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_SaveAllStoredShapesToBinaryFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::SaveAllStoredShapesToBinaryFile",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveAllStoredShapesToBinaryFile",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveAllStoredShapesToBinaryFile",2,"Mezzanine::String const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_SaveAllStoredShapesToBinaryFile",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  (arg1)->SaveAllStoredShapesToBinaryFile((Mezzanine::String const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_SaveShapesToBinaryFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Physics::CollisionShapeManager::ShapeVector *arg3 = 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::SaveShapesToBinaryFile",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveShapesToBinaryFile",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveShapesToBinaryFile",2,"Mezzanine::String const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SaveShapesToBinaryFile",3,"Mezzanine::Physics::CollisionShapeManager::ShapeVector &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_SaveShapesToBinaryFile",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t,0))){
    SWIG_fail_ptr("CollisionShapeManager_SaveShapesToBinaryFile",3,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t);
  }
  
  (arg1)->SaveShapesToBinaryFile((Mezzanine::String const &)*arg2,*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GetUnnamedShapes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::Physics::CollisionShapeManager::ShapeVector *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GetUnnamedShapes",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GetUnnamedShapes",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GetUnnamedShapes",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  result = (Mezzanine::Physics::CollisionShapeManager::ShapeVector *) &(arg1)->GetUnnamedShapes();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_SetNameForUnnamedShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Physics::CollisionShape *arg3 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::SetNameForUnnamedShape",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SetNameForUnnamedShape",1,"Mezzanine::Physics::CollisionShapeManager *");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SetNameForUnnamedShape",2,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::SetNameForUnnamedShape",3,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_SetNameForUnnamedShape",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollisionShapeManager_SetNameForUnnamedShape",3,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->SetNameForUnnamedShape((Mezzanine::String const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_Initialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::Initialize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::Initialize",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_Initialize",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  (arg1)->Initialize();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_Deinitialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::Deinitialize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::Deinitialize",1,"Mezzanine::Physics::CollisionShapeManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_Deinitialize",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  (arg1)->Deinitialize();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GetInterfaceType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  ManagerBase::ManagerType result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GetInterfaceType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GetInterfaceType",1,"Mezzanine::Physics::CollisionShapeManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GetInterfaceType",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  result = ((Mezzanine::Physics::CollisionShapeManager const *)arg1)->GetInterfaceType();
  {
    ManagerBase::ManagerType * resultptr = new ManagerBase::ManagerType((const ManagerBase::ManagerType &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ManagerBase__ManagerType,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollisionShapeManager_GetImplementationTypeName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollisionShapeManager::GetImplementationTypeName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollisionShapeManager::GetImplementationTypeName",1,"Mezzanine::Physics::CollisionShapeManager const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,0))){
    SWIG_fail_ptr("CollisionShapeManager_GetImplementationTypeName",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager);
  }
  
  result = ((Mezzanine::Physics::CollisionShapeManager const *)arg1)->GetImplementationTypeName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CollisionShapeManager(void *obj) {
Mezzanine::Physics::CollisionShapeManager *arg1 = (Mezzanine::Physics::CollisionShapeManager *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CollisionShapeManager_methods[] = {
    {"StoreShape", _wrap_CollisionShapeManager_StoreShape}, 
    {"GetShape", _wrap_CollisionShapeManager_GetShape}, 
    {"GetNumStoredShapes", _wrap_CollisionShapeManager_GetNumStoredShapes}, 
    {"RemoveShape", _wrap_CollisionShapeManager_RemoveShape}, 
    {"RemoveAllShapes", _wrap_CollisionShapeManager_RemoveAllShapes}, 
    {"DestroyShape", _wrap_CollisionShapeManager_DestroyShape}, 
    {"DestroyAllShapes", _wrap_CollisionShapeManager_DestroyAllShapes}, 
    {"BeginCollisionShape", _wrap_CollisionShapeManager_BeginCollisionShape}, 
    {"EndCollisionShape", _wrap_CollisionShapeManager_EndCollisionShape}, 
    {"GenerateConvexHull", _wrap_CollisionShapeManager_GenerateConvexHull}, 
    {"GenerateDynamicTriMesh", _wrap_CollisionShapeManager_GenerateDynamicTriMesh}, 
    {"GenerateStaticTriMesh", _wrap_CollisionShapeManager_GenerateStaticTriMesh}, 
    {"PerformConvexDecomposition", _wrap_CollisionShapeManager_PerformConvexDecomposition}, 
    {"LoadAllShapesFromXMLFile", _wrap_CollisionShapeManager_LoadAllShapesFromXMLFile}, 
    {"SaveAllStoredShapesToXMLFile", _wrap_CollisionShapeManager_SaveAllStoredShapesToXMLFile}, 
    {"SaveShapesToXMLFile", _wrap_CollisionShapeManager_SaveShapesToXMLFile}, 
    {"LoadAllShapesFromBinaryFile", _wrap_CollisionShapeManager_LoadAllShapesFromBinaryFile}, 
    {"SaveAllStoredShapesToBinaryFile", _wrap_CollisionShapeManager_SaveAllStoredShapesToBinaryFile}, 
    {"SaveShapesToBinaryFile", _wrap_CollisionShapeManager_SaveShapesToBinaryFile}, 
    {"GetUnnamedShapes", _wrap_CollisionShapeManager_GetUnnamedShapes}, 
    {"SetNameForUnnamedShape", _wrap_CollisionShapeManager_SetNameForUnnamedShape}, 
    {"Initialize", _wrap_CollisionShapeManager_Initialize}, 
    {"Deinitialize", _wrap_CollisionShapeManager_Deinitialize}, 
    {"GetInterfaceType", _wrap_CollisionShapeManager_GetInterfaceType}, 
    {"GetImplementationTypeName", _wrap_CollisionShapeManager_GetImplementationTypeName}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CollisionShapeManager_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CollisionShapeManager_bases[] = {0};
static const char *swig_Mezzanine_Physics_CollisionShapeManager_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CollisionShapeManager = { "CollisionShapeManager", &SWIGTYPE_p_Mezzanine__Physics__CollisionShapeManager,_wrap_new_CollisionShapeManager, swig_delete_CollisionShapeManager, swig_Mezzanine_Physics_CollisionShapeManager_methods, swig_Mezzanine_Physics_CollisionShapeManager_attributes, swig_Mezzanine_Physics_CollisionShapeManager_bases, swig_Mezzanine_Physics_CollisionShapeManager_base_names };

static int _wrap_new_DefaultCollisionShapeManagerFactory(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultCollisionShapeManagerFactory *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::DefaultCollisionShapeManagerFactory",0,0)
  result = (Mezzanine::Physics::DefaultCollisionShapeManagerFactory *)new Mezzanine::Physics::DefaultCollisionShapeManagerFactory();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultCollisionShapeManagerFactory_GetManagerTypeName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultCollisionShapeManagerFactory *arg1 = (Mezzanine::Physics::DefaultCollisionShapeManagerFactory *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::GetManagerTypeName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::GetManagerTypeName",1,"Mezzanine::Physics::DefaultCollisionShapeManagerFactory const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_GetManagerTypeName",1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory);
  }
  
  result = ((Mezzanine::Physics::DefaultCollisionShapeManagerFactory const *)arg1)->GetManagerTypeName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultCollisionShapeManagerFactory_CreateManager__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultCollisionShapeManagerFactory *arg1 = (Mezzanine::Physics::DefaultCollisionShapeManagerFactory *) 0 ;
  Mezzanine::NameValuePairList *arg2 = 0 ;
  ManagerBase *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager",1,"Mezzanine::Physics::DefaultCollisionShapeManagerFactory *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager",2,"Mezzanine::NameValuePairList &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_CreateManager",1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_CreateManager",2,SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t);
  }
  
  result = (ManagerBase *)(arg1)->CreateManager(*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_ManagerBase,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultCollisionShapeManagerFactory_CreateManager__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultCollisionShapeManagerFactory *arg1 = (Mezzanine::Physics::DefaultCollisionShapeManagerFactory *) 0 ;
  XML::Node *arg2 = 0 ;
  ManagerBase *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager",1,"Mezzanine::Physics::DefaultCollisionShapeManagerFactory *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_CreateManager",1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_CreateManager",2,SWIGTYPE_p_XML__Node);
  }
  
  result = (ManagerBase *)(arg1)->CreateManager(*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_ManagerBase,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DefaultCollisionShapeManagerFactory_CreateManager(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_DefaultCollisionShapeManagerFactory_CreateManager__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_DefaultCollisionShapeManagerFactory_CreateManager__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'DefaultCollisionShapeManagerFactory_CreateManager'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager(Mezzanine::NameValuePairList &)\n"
    "    Mezzanine::Physics::DefaultCollisionShapeManagerFactory::CreateManager(XML::Node &)\n");
  lua_error(L);return 0;
}


static int _wrap_DefaultCollisionShapeManagerFactory_DestroyManager(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DefaultCollisionShapeManagerFactory *arg1 = (Mezzanine::Physics::DefaultCollisionShapeManagerFactory *) 0 ;
  ManagerBase *arg2 = (ManagerBase *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::DestroyManager",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::DestroyManager",1,"Mezzanine::Physics::DefaultCollisionShapeManagerFactory *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::DefaultCollisionShapeManagerFactory::DestroyManager",2,"ManagerBase *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_DestroyManager",1,SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ManagerBase,0))){
    SWIG_fail_ptr("DefaultCollisionShapeManagerFactory_DestroyManager",2,SWIGTYPE_p_ManagerBase);
  }
  
  (arg1)->DestroyManager(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DefaultCollisionShapeManagerFactory(void *obj) {
Mezzanine::Physics::DefaultCollisionShapeManagerFactory *arg1 = (Mezzanine::Physics::DefaultCollisionShapeManagerFactory *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_methods[] = {
    {"GetManagerTypeName", _wrap_DefaultCollisionShapeManagerFactory_GetManagerTypeName}, 
    {"CreateManager", _wrap_DefaultCollisionShapeManagerFactory_CreateManager}, 
    {"DestroyManager", _wrap_DefaultCollisionShapeManagerFactory_DestroyManager}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_bases[] = {0};
static const char *swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_DefaultCollisionShapeManagerFactory = { "DefaultCollisionShapeManagerFactory", &SWIGTYPE_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,_wrap_new_DefaultCollisionShapeManagerFactory, swig_delete_DefaultCollisionShapeManagerFactory, swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_methods, swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_attributes, swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_bases, swig_Mezzanine_Physics_DefaultCollisionShapeManagerFactory_base_names };

static int _wrap_PrimitiveCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PrimitiveCollisionShape *arg1 = (Mezzanine::Physics::PrimitiveCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::PrimitiveCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PrimitiveCollisionShape::GetType",1,"Mezzanine::Physics::PrimitiveCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape,0))){
    SWIG_fail_ptr("PrimitiveCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::PrimitiveCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PrimitiveCollisionShape_GetBulletConvexShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PrimitiveCollisionShape *arg1 = (Mezzanine::Physics::PrimitiveCollisionShape *) 0 ;
  btConvexInternalShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PrimitiveCollisionShape::GetBulletConvexShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PrimitiveCollisionShape::GetBulletConvexShape",1,"Mezzanine::Physics::PrimitiveCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape,0))){
    SWIG_fail_ptr("PrimitiveCollisionShape_GetBulletConvexShape",1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape);
  }
  
  result = (btConvexInternalShape *)((Mezzanine::Physics::PrimitiveCollisionShape const *)arg1)->GetBulletConvexShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btConvexInternalShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PrimitiveCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PrimitiveCollisionShape *arg1 = (Mezzanine::Physics::PrimitiveCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PrimitiveCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PrimitiveCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::PrimitiveCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PrimitiveCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape,0))){
    SWIG_fail_ptr("PrimitiveCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PrimitiveCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::PrimitiveCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PrimitiveCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PrimitiveCollisionShape *arg1 = (Mezzanine::Physics::PrimitiveCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PrimitiveCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PrimitiveCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::PrimitiveCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PrimitiveCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape,0))){
    SWIG_fail_ptr("PrimitiveCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PrimitiveCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PrimitiveCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::PrimitiveCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::PrimitiveCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_PrimitiveCollisionShape(void *obj) {
Mezzanine::Physics::PrimitiveCollisionShape *arg1 = (Mezzanine::Physics::PrimitiveCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_PrimitiveCollisionShape_methods[] = {
    {"GetType", _wrap_PrimitiveCollisionShape_GetType}, 
    {"GetBulletConvexShape", _wrap_PrimitiveCollisionShape_GetBulletConvexShape}, 
    {"ProtoSerialize", _wrap_PrimitiveCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_PrimitiveCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_PrimitiveCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_PrimitiveCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_PrimitiveCollisionShape_base_names[] = {"Mezzanine::Physics::CollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_PrimitiveCollisionShape = { "PrimitiveCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__PrimitiveCollisionShape,0, swig_delete_PrimitiveCollisionShape, swig_Mezzanine_Physics_PrimitiveCollisionShape_methods, swig_Mezzanine_Physics_PrimitiveCollisionShape_attributes, swig_Mezzanine_Physics_PrimitiveCollisionShape_bases, swig_Mezzanine_Physics_PrimitiveCollisionShape_base_names };

static int _wrap_new_BoxCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::BoxCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",2,"Mezzanine::Physics::Vector3 const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_BoxCollisionShape",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::BoxCollisionShape *)new Mezzanine::Physics::BoxCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Physics::Vector3 const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_BoxCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btBoxShape *arg2 = (btBoxShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::BoxCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",2,"btBoxShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btBoxShape,0))){
    SWIG_fail_ptr("new_BoxCollisionShape",2,SWIGTYPE_p_btBoxShape);
  }
  
  result = (Mezzanine::Physics::BoxCollisionShape *)new Mezzanine::Physics::BoxCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_BoxCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::BoxCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_BoxCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::BoxCollisionShape *)new Mezzanine::Physics::BoxCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_BoxCollisionShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_BoxCollisionShape__SWIG_2(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btBoxShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_BoxCollisionShape__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_BoxCollisionShape__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_BoxCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape(Mezzanine::String const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape(Mezzanine::String const &,btBoxShape *)\n"
    "    Mezzanine::Physics::BoxCollisionShape::BoxCollisionShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_BoxCollisionShape_GetCleanHalfExtents(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::GetCleanHalfExtents",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::GetCleanHalfExtents",1,"Mezzanine::Physics::BoxCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_GetCleanHalfExtents",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  result = ((Mezzanine::Physics::BoxCollisionShape const *)arg1)->GetCleanHalfExtents();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_GetHalfExtents(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::GetHalfExtents",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::GetHalfExtents",1,"Mezzanine::Physics::BoxCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_GetHalfExtents",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  result = ((Mezzanine::Physics::BoxCollisionShape const *)arg1)->GetHalfExtents();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_GetHalfExtentsWithMargin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::GetHalfExtentsWithMargin",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::GetHalfExtentsWithMargin",1,"Mezzanine::Physics::BoxCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_GetHalfExtentsWithMargin",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  result = ((Mezzanine::Physics::BoxCollisionShape const *)arg1)->GetHalfExtentsWithMargin();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_IsInside(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::IsInside",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::IsInside",1,"Mezzanine::Physics::BoxCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::IsInside",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::IsInside",3,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_IsInside",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("BoxCollisionShape_IsInside",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  result = (Mezzanine::Boole)((Mezzanine::Physics::BoxCollisionShape const *)arg1)->IsInside((Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Real const &)*arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::GetType",1,"Mezzanine::Physics::BoxCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::BoxCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_GetBulletBoxShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  btBoxShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::GetBulletBoxShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::GetBulletBoxShape",1,"Mezzanine::Physics::BoxCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_GetBulletBoxShape",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  result = (btBoxShape *)((Mezzanine::Physics::BoxCollisionShape const *)arg1)->GetBulletBoxShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btBoxShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::BoxCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("BoxCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::BoxCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::BoxCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::BoxCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,0))){
    SWIG_fail_ptr("BoxCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("BoxCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_BoxCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::BoxCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::BoxCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_BoxCollisionShape(void *obj) {
Mezzanine::Physics::BoxCollisionShape *arg1 = (Mezzanine::Physics::BoxCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_BoxCollisionShape_methods[] = {
    {"GetCleanHalfExtents", _wrap_BoxCollisionShape_GetCleanHalfExtents}, 
    {"GetHalfExtents", _wrap_BoxCollisionShape_GetHalfExtents}, 
    {"GetHalfExtentsWithMargin", _wrap_BoxCollisionShape_GetHalfExtentsWithMargin}, 
    {"IsInside", _wrap_BoxCollisionShape_IsInside}, 
    {"GetType", _wrap_BoxCollisionShape_GetType}, 
    {"GetBulletBoxShape", _wrap_BoxCollisionShape_GetBulletBoxShape}, 
    {"ProtoSerialize", _wrap_BoxCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_BoxCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_BoxCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_BoxCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_BoxCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_BoxCollisionShape = { "BoxCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__BoxCollisionShape,_wrap_new_BoxCollisionShape, swig_delete_BoxCollisionShape, swig_Mezzanine_Physics_BoxCollisionShape_methods, swig_Mezzanine_Physics_BoxCollisionShape_attributes, swig_Mezzanine_Physics_BoxCollisionShape_bases, swig_Mezzanine_Physics_BoxCollisionShape_base_names };

static int _wrap_new_CapsuleCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Physics::CapsuleCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",3,"Mezzanine::Real const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",4,"Mezzanine::Physics::Vector3 const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_CapsuleCollisionShape",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::CapsuleCollisionShape *)new Mezzanine::Physics::CapsuleCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CapsuleCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  StandardAxis arg4 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  StandardAxis *argp4 ;
  Mezzanine::Physics::CapsuleCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",3,"Mezzanine::Real const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",4,"StandardAxis");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_StandardAxis,0))){
    SWIG_fail_ptr("new_CapsuleCollisionShape",4,SWIGTYPE_p_StandardAxis);
  }
  arg4 = *argp4;
  
  result = (Mezzanine::Physics::CapsuleCollisionShape *)new Mezzanine::Physics::CapsuleCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CapsuleCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::CapsuleCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_CapsuleCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::CapsuleCollisionShape *)new Mezzanine::Physics::CapsuleCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CapsuleCollisionShape__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btCapsuleShape *arg2 = (btCapsuleShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CapsuleCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape",2,"btCapsuleShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btCapsuleShape,0))){
    SWIG_fail_ptr("new_CapsuleCollisionShape",2,SWIGTYPE_p_btCapsuleShape);
  }
  
  result = (Mezzanine::Physics::CapsuleCollisionShape *)new Mezzanine::Physics::CapsuleCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CapsuleCollisionShape(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_CapsuleCollisionShape__SWIG_2(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btCapsuleShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_CapsuleCollisionShape__SWIG_3(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_CapsuleCollisionShape__SWIG_0(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_StandardAxis, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_CapsuleCollisionShape__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_CapsuleCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape(Mezzanine::String const &,Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape(Mezzanine::String const &,Mezzanine::Real const &,Mezzanine::Real const &,StandardAxis)\n"
    "    Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape(XML::Node)\n"
    "    Mezzanine::Physics::CapsuleCollisionShape::CapsuleCollisionShape(Mezzanine::String const &,btCapsuleShape *)\n");
  lua_error(L);return 0;
}


static int _wrap_CapsuleCollisionShape_GetRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetRadius",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetRadius",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetRadius",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetRadius();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetHeight(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetHeight",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetHeight",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetHeight",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetHeight();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetCleanRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetCleanRadius",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetCleanRadius",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetCleanRadius",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetCleanRadius();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetCleanHeight(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetCleanHeight",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetCleanHeight",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetCleanHeight",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetCleanHeight();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetUpAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetUpAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetUpAxis",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetUpAxis",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = ((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetUpAxis();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetUpStandardAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  StandardAxis result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetUpStandardAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetUpStandardAxis",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetUpStandardAxis",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = ((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetUpStandardAxis();
  {
    StandardAxis * resultptr = new StandardAxis((const StandardAxis &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_StandardAxis,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetType",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_GetBulletCapsuleShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  btCapsuleShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::GetBulletCapsuleShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::GetBulletCapsuleShape",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_GetBulletCapsuleShape",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  result = (btCapsuleShape *)((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->GetBulletCapsuleShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCapsuleShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::CapsuleCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::CapsuleCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::CapsuleCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CapsuleCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CapsuleCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CapsuleCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CapsuleCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::CapsuleCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CapsuleCollisionShape(void *obj) {
Mezzanine::Physics::CapsuleCollisionShape *arg1 = (Mezzanine::Physics::CapsuleCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CapsuleCollisionShape_methods[] = {
    {"GetRadius", _wrap_CapsuleCollisionShape_GetRadius}, 
    {"GetHeight", _wrap_CapsuleCollisionShape_GetHeight}, 
    {"GetCleanRadius", _wrap_CapsuleCollisionShape_GetCleanRadius}, 
    {"GetCleanHeight", _wrap_CapsuleCollisionShape_GetCleanHeight}, 
    {"GetUpAxis", _wrap_CapsuleCollisionShape_GetUpAxis}, 
    {"GetUpStandardAxis", _wrap_CapsuleCollisionShape_GetUpStandardAxis}, 
    {"GetType", _wrap_CapsuleCollisionShape_GetType}, 
    {"GetBulletCapsuleShape", _wrap_CapsuleCollisionShape_GetBulletCapsuleShape}, 
    {"ProtoSerialize", _wrap_CapsuleCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_CapsuleCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CapsuleCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CapsuleCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_CapsuleCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CapsuleCollisionShape = { "CapsuleCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__CapsuleCollisionShape,_wrap_new_CapsuleCollisionShape, swig_delete_CapsuleCollisionShape, swig_Mezzanine_Physics_CapsuleCollisionShape_methods, swig_Mezzanine_Physics_CapsuleCollisionShape_attributes, swig_Mezzanine_Physics_CapsuleCollisionShape_bases, swig_Mezzanine_Physics_CapsuleCollisionShape_base_names };

static int _wrap_CollidablePair_ProxyA_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::ProxyA",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::ProxyA",1,"Mezzanine::Physics::CollidablePair *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::ProxyA",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair_ProxyA_set",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,SWIG_POINTER_DISOWN))){
    SWIG_fail_ptr("CollidablePair_ProxyA_set",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  if (arg1) (arg1)->ProxyA = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidablePair_ProxyA_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::ProxyA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::ProxyA",1,"Mezzanine::Physics::CollidablePair *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair_ProxyA_get",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  result = (Mezzanine::Physics::CollidableProxy *) ((arg1)->ProxyA);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidablePair_ProxyB_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::ProxyB",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::ProxyB",1,"Mezzanine::Physics::CollidablePair *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::ProxyB",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair_ProxyB_set",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,SWIG_POINTER_DISOWN))){
    SWIG_fail_ptr("CollidablePair_ProxyB_set",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  if (arg1) (arg1)->ProxyB = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidablePair_ProxyB_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::ProxyB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::ProxyB",1,"Mezzanine::Physics::CollidablePair *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair_ProxyB_get",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  result = (Mezzanine::Physics::CollidableProxy *) ((arg1)->ProxyB);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CollidablePair(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::CollidablePair *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::CollidablePair",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::CollidablePair",1,"Mezzanine::Physics::CollidableProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::CollidablePair",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("new_CollidablePair",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("new_CollidablePair",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Physics::CollidablePair *)new Mezzanine::Physics::CollidablePair(arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidablePair_PairsMatch(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidablePair *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::PairsMatch",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::PairsMatch",1,"Mezzanine::Physics::CollidablePair const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::PairsMatch",2,"Mezzanine::Physics::CollidablePair const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair_PairsMatch",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair_PairsMatch",2,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidablePair const *)arg1)->PairsMatch((Mezzanine::Physics::CollidablePair const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidablePair___eq(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidablePair *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::operator ==",1,"Mezzanine::Physics::CollidablePair const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::operator ==",2,"Mezzanine::Physics::CollidablePair const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair___eq",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair___eq",2,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidablePair const *)arg1)->operator ==((Mezzanine::Physics::CollidablePair const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidablePair___lt(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) 0 ;
  Mezzanine::Physics::CollidablePair *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidablePair::operator <",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::operator <",1,"Mezzanine::Physics::CollidablePair const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidablePair::operator <",2,"Mezzanine::Physics::CollidablePair const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair___lt",1,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidablePair,0))){
    SWIG_fail_ptr("CollidablePair___lt",2,SWIGTYPE_p_Mezzanine__Physics__CollidablePair);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidablePair const *)arg1)->operator <((Mezzanine::Physics::CollidablePair const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CollidablePair(void *obj) {
Mezzanine::Physics::CollidablePair *arg1 = (Mezzanine::Physics::CollidablePair *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CollidablePair_methods[] = {
    {"PairsMatch", _wrap_CollidablePair_PairsMatch}, 
    {"__eq", _wrap_CollidablePair___eq}, 
    {"__lt", _wrap_CollidablePair___lt}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CollidablePair_attributes[] = {
    { "ProxyA", _wrap_CollidablePair_ProxyA_get, _wrap_CollidablePair_ProxyA_set},
    { "ProxyB", _wrap_CollidablePair_ProxyB_get, _wrap_CollidablePair_ProxyB_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CollidablePair_bases[] = {0};
static const char *swig_Mezzanine_Physics_CollidablePair_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CollidablePair = { "CollidablePair", &SWIGTYPE_p_Mezzanine__Physics__CollidablePair,_wrap_new_CollidablePair, swig_delete_CollidablePair, swig_Mezzanine_Physics_CollidablePair_methods, swig_Mezzanine_Physics_CollidablePair_attributes, swig_Mezzanine_Physics_CollidablePair_bases, swig_Mezzanine_Physics_CollidablePair_base_names };

static int _wrap_Exception_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Exception::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::GetExceptionCode",1,"Mezzanine::Exception const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::Exception const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Exception_GetExceptionTypeName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::ConstString *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Exception::GetExceptionTypeName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::GetExceptionTypeName",1,"Mezzanine::Exception const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_GetExceptionTypeName",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = (Mezzanine::ConstString *) &((Mezzanine::Exception const *)arg1)->GetExceptionTypeName();
  lua_pushlstring(L,result->data(),result->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Exception_GetFunction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::ConstString *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Exception::GetFunction",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::GetFunction",1,"Mezzanine::Exception const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_GetFunction",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = (Mezzanine::ConstString *) &((Mezzanine::Exception const *)arg1)->GetFunction();
  lua_pushlstring(L,result->data(),result->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Exception_GetFile(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::ConstString *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Exception::GetFile",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::GetFile",1,"Mezzanine::Exception const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_GetFile",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = (Mezzanine::ConstString *) &((Mezzanine::Exception const *)arg1)->GetFile();
  lua_pushlstring(L,result->data(),result->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Exception_GetLine(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::Whole *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Exception::GetLine",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::GetLine",1,"Mezzanine::Exception const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_GetLine",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = (Mezzanine::Whole *) &((Mezzanine::Exception const *)arg1)->GetLine();
  lua_pushnumber(L, (lua_Number) *result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Exception_GetCompleteMessage(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Exception::GetCompleteMessage",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::GetCompleteMessage",1,"Mezzanine::Exception const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_GetCompleteMessage",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = ((Mezzanine::Exception const *)arg1)->GetCompleteMessage();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Exception_what(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Exception *arg1 = (Mezzanine::Exception *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Exception::what",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Exception::what",1,"Mezzanine::Exception *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Exception,0))){
    SWIG_fail_ptr("Exception_what",1,SWIGTYPE_p_Mezzanine__Exception);
  }
  
  result = (arg1)->what();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Exception(void *obj) {
Mezzanine::Exception *arg1 = (Mezzanine::Exception *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Exception_methods[] = {
    {"GetExceptionCode", _wrap_Exception_GetExceptionCode}, 
    {"GetExceptionTypeName", _wrap_Exception_GetExceptionTypeName}, 
    {"GetFunction", _wrap_Exception_GetFunction}, 
    {"GetFile", _wrap_Exception_GetFile}, 
    {"GetLine", _wrap_Exception_GetLine}, 
    {"GetCompleteMessage", _wrap_Exception_GetCompleteMessage}, 
    {"what", _wrap_Exception_what}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Exception_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Exception_bases[] = {0};
static const char *swig_Mezzanine_Exception_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Exception = { "Exception", &SWIGTYPE_p_Mezzanine__Exception,0, swig_delete_Exception, swig_Mezzanine_Exception_methods, swig_Mezzanine_Exception_attributes, swig_Mezzanine_Exception_bases, swig_Mezzanine_Exception_base_names };

static int _wrap_new_IOException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::IOException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::IOException::IOException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::IOException::IOException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::IOException::IOException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::IOException::IOException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::IOException::IOException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::IOException::IOException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::IOException *)new Mezzanine::IOException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__IOException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_IOException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::IOException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::IOException::IOException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::IOException::IOException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::IOException::IOException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::IOException::IOException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::IOException::IOException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::IOException *)new Mezzanine::IOException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__IOException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_IOException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_IOException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_IOException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_IOException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::IOException::IOException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::IOException::IOException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_IOException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::IOException *arg1 = (Mezzanine::IOException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::IOException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::IOException::GetExceptionCode",1,"Mezzanine::IOException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__IOException,0))){
    SWIG_fail_ptr("IOException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__IOException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::IOException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_IOException(void *obj) {
Mezzanine::IOException *arg1 = (Mezzanine::IOException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_IOException_methods[] = {
    {"GetExceptionCode", _wrap_IOException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_IOException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_IOException_bases[] = {0,0};
static const char *swig_Mezzanine_IOException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_IOException = { "IOException", &SWIGTYPE_p_Mezzanine__IOException,_wrap_new_IOException, swig_delete_IOException, swig_Mezzanine_IOException_methods, swig_Mezzanine_IOException_attributes, swig_Mezzanine_IOException_bases, swig_Mezzanine_IOException_base_names };

static int _wrap_new_FileException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::FileException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileException::FileException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileException::FileException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileException::FileException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileException::FileException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::FileException::FileException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::FileException::FileException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::FileException *)new Mezzanine::FileException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::FileException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileException::FileException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileException::FileException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileException::FileException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileException::FileException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::FileException::FileException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::FileException *)new Mezzanine::FileException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_FileException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_FileException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_FileException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::FileException::FileException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::FileException::FileException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_FileException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::FileException *arg1 = (Mezzanine::FileException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::FileException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::FileException::GetExceptionCode",1,"Mezzanine::FileException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__FileException,0))){
    SWIG_fail_ptr("FileException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__FileException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::FileException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_FileException(void *obj) {
Mezzanine::FileException *arg1 = (Mezzanine::FileException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_FileException_methods[] = {
    {"GetExceptionCode", _wrap_FileException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_FileException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_FileException_bases[] = {0,0};
static const char *swig_Mezzanine_FileException_base_names[] = {"Mezzanine::IOException *",0};
static swig_lua_class _wrap_class_Mezzanine_FileException = { "FileException", &SWIGTYPE_p_Mezzanine__FileException,_wrap_new_FileException, swig_delete_FileException, swig_Mezzanine_FileException_methods, swig_Mezzanine_FileException_attributes, swig_Mezzanine_FileException_bases, swig_Mezzanine_FileException_base_names };

static int _wrap_new_FileReadException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::FileReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileReadException::FileReadException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::FileReadException *)new Mezzanine::FileReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileReadException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::FileReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileReadException::FileReadException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::FileReadException::FileReadException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::FileReadException *)new Mezzanine::FileReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileReadException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_FileReadException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_FileReadException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_FileReadException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::FileReadException::FileReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::FileReadException::FileReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_FileReadException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::FileReadException *arg1 = (Mezzanine::FileReadException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::FileReadException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::FileReadException::GetExceptionCode",1,"Mezzanine::FileReadException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__FileReadException,0))){
    SWIG_fail_ptr("FileReadException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__FileReadException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::FileReadException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_FileReadException(void *obj) {
Mezzanine::FileReadException *arg1 = (Mezzanine::FileReadException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_FileReadException_methods[] = {
    {"GetExceptionCode", _wrap_FileReadException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_FileReadException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_FileReadException_bases[] = {0,0};
static const char *swig_Mezzanine_FileReadException_base_names[] = {"Mezzanine::FileException *",0};
static swig_lua_class _wrap_class_Mezzanine_FileReadException = { "FileReadException", &SWIGTYPE_p_Mezzanine__FileReadException,_wrap_new_FileReadException, swig_delete_FileReadException, swig_Mezzanine_FileReadException_methods, swig_Mezzanine_FileReadException_attributes, swig_Mezzanine_FileReadException_bases, swig_Mezzanine_FileReadException_base_names };

static int _wrap_new_FileWriteException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::FileWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileWriteException::FileWriteException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::FileWriteException *)new Mezzanine::FileWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileWriteException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::FileWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileWriteException::FileWriteException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::FileWriteException::FileWriteException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::FileWriteException *)new Mezzanine::FileWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileWriteException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_FileWriteException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_FileWriteException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_FileWriteException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::FileWriteException::FileWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::FileWriteException::FileWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_FileWriteException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::FileWriteException *arg1 = (Mezzanine::FileWriteException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::FileWriteException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::FileWriteException::GetExceptionCode",1,"Mezzanine::FileWriteException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__FileWriteException,0))){
    SWIG_fail_ptr("FileWriteException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__FileWriteException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::FileWriteException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_FileWriteException(void *obj) {
Mezzanine::FileWriteException *arg1 = (Mezzanine::FileWriteException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_FileWriteException_methods[] = {
    {"GetExceptionCode", _wrap_FileWriteException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_FileWriteException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_FileWriteException_bases[] = {0,0};
static const char *swig_Mezzanine_FileWriteException_base_names[] = {"Mezzanine::FileException *",0};
static swig_lua_class _wrap_class_Mezzanine_FileWriteException = { "FileWriteException", &SWIGTYPE_p_Mezzanine__FileWriteException,_wrap_new_FileWriteException, swig_delete_FileWriteException, swig_Mezzanine_FileWriteException_methods, swig_Mezzanine_FileWriteException_attributes, swig_Mezzanine_FileWriteException_bases, swig_Mezzanine_FileWriteException_base_names };

static int _wrap_new_FileNotFoundException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::FileNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileNotFoundException::FileNotFoundException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::FileNotFoundException *)new Mezzanine::FileNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileNotFoundException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::FileNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FileNotFoundException::FileNotFoundException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::FileNotFoundException::FileNotFoundException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::FileNotFoundException *)new Mezzanine::FileNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FileNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FileNotFoundException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_FileNotFoundException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_FileNotFoundException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_FileNotFoundException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::FileNotFoundException::FileNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::FileNotFoundException::FileNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_FileNotFoundException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::FileNotFoundException *arg1 = (Mezzanine::FileNotFoundException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::FileNotFoundException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::FileNotFoundException::GetExceptionCode",1,"Mezzanine::FileNotFoundException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__FileNotFoundException,0))){
    SWIG_fail_ptr("FileNotFoundException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__FileNotFoundException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::FileNotFoundException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_FileNotFoundException(void *obj) {
Mezzanine::FileNotFoundException *arg1 = (Mezzanine::FileNotFoundException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_FileNotFoundException_methods[] = {
    {"GetExceptionCode", _wrap_FileNotFoundException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_FileNotFoundException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_FileNotFoundException_bases[] = {0,0};
static const char *swig_Mezzanine_FileNotFoundException_base_names[] = {"Mezzanine::FileException *",0};
static swig_lua_class _wrap_class_Mezzanine_FileNotFoundException = { "FileNotFoundException", &SWIGTYPE_p_Mezzanine__FileNotFoundException,_wrap_new_FileNotFoundException, swig_delete_FileNotFoundException, swig_Mezzanine_FileNotFoundException_methods, swig_Mezzanine_FileNotFoundException_attributes, swig_Mezzanine_FileNotFoundException_bases, swig_Mezzanine_FileNotFoundException_base_names };

static int _wrap_new_FilePermissionException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::FilePermissionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FilePermissionException::FilePermissionException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::FilePermissionException *)new Mezzanine::FilePermissionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FilePermissionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FilePermissionException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::FilePermissionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::FilePermissionException::FilePermissionException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::FilePermissionException::FilePermissionException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::FilePermissionException *)new Mezzanine::FilePermissionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__FilePermissionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_FilePermissionException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_FilePermissionException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_FilePermissionException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_FilePermissionException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::FilePermissionException::FilePermissionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::FilePermissionException::FilePermissionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_FilePermissionException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::FilePermissionException *arg1 = (Mezzanine::FilePermissionException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::FilePermissionException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::FilePermissionException::GetExceptionCode",1,"Mezzanine::FilePermissionException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__FilePermissionException,0))){
    SWIG_fail_ptr("FilePermissionException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__FilePermissionException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::FilePermissionException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_FilePermissionException(void *obj) {
Mezzanine::FilePermissionException *arg1 = (Mezzanine::FilePermissionException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_FilePermissionException_methods[] = {
    {"GetExceptionCode", _wrap_FilePermissionException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_FilePermissionException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_FilePermissionException_bases[] = {0,0};
static const char *swig_Mezzanine_FilePermissionException_base_names[] = {"Mezzanine::FileException *",0};
static swig_lua_class _wrap_class_Mezzanine_FilePermissionException = { "FilePermissionException", &SWIGTYPE_p_Mezzanine__FilePermissionException,_wrap_new_FilePermissionException, swig_delete_FilePermissionException, swig_Mezzanine_FilePermissionException_methods, swig_Mezzanine_FilePermissionException_attributes, swig_Mezzanine_FilePermissionException_bases, swig_Mezzanine_FilePermissionException_base_names };

static int _wrap_new_DirectoryException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::DirectoryException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryException::DirectoryException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::DirectoryException *)new Mezzanine::DirectoryException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::DirectoryException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryException::DirectoryException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::DirectoryException::DirectoryException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::DirectoryException *)new Mezzanine::DirectoryException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_DirectoryException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_DirectoryException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_DirectoryException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::DirectoryException::DirectoryException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::DirectoryException::DirectoryException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_DirectoryException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::DirectoryException *arg1 = (Mezzanine::DirectoryException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::DirectoryException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::DirectoryException::GetExceptionCode",1,"Mezzanine::DirectoryException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__DirectoryException,0))){
    SWIG_fail_ptr("DirectoryException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__DirectoryException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::DirectoryException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DirectoryException(void *obj) {
Mezzanine::DirectoryException *arg1 = (Mezzanine::DirectoryException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_DirectoryException_methods[] = {
    {"GetExceptionCode", _wrap_DirectoryException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_DirectoryException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_DirectoryException_bases[] = {0,0};
static const char *swig_Mezzanine_DirectoryException_base_names[] = {"Mezzanine::IOException *",0};
static swig_lua_class _wrap_class_Mezzanine_DirectoryException = { "DirectoryException", &SWIGTYPE_p_Mezzanine__DirectoryException,_wrap_new_DirectoryException, swig_delete_DirectoryException, swig_Mezzanine_DirectoryException_methods, swig_Mezzanine_DirectoryException_attributes, swig_Mezzanine_DirectoryException_bases, swig_Mezzanine_DirectoryException_base_names };

static int _wrap_new_DirectoryReadException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::DirectoryReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryReadException::DirectoryReadException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::DirectoryReadException *)new Mezzanine::DirectoryReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryReadException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::DirectoryReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryReadException::DirectoryReadException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::DirectoryReadException::DirectoryReadException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::DirectoryReadException *)new Mezzanine::DirectoryReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryReadException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_DirectoryReadException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_DirectoryReadException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_DirectoryReadException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::DirectoryReadException::DirectoryReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::DirectoryReadException::DirectoryReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_DirectoryReadException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::DirectoryReadException *arg1 = (Mezzanine::DirectoryReadException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::DirectoryReadException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::DirectoryReadException::GetExceptionCode",1,"Mezzanine::DirectoryReadException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__DirectoryReadException,0))){
    SWIG_fail_ptr("DirectoryReadException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__DirectoryReadException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::DirectoryReadException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DirectoryReadException(void *obj) {
Mezzanine::DirectoryReadException *arg1 = (Mezzanine::DirectoryReadException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_DirectoryReadException_methods[] = {
    {"GetExceptionCode", _wrap_DirectoryReadException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_DirectoryReadException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_DirectoryReadException_bases[] = {0,0};
static const char *swig_Mezzanine_DirectoryReadException_base_names[] = {"Mezzanine::DirectoryException *",0};
static swig_lua_class _wrap_class_Mezzanine_DirectoryReadException = { "DirectoryReadException", &SWIGTYPE_p_Mezzanine__DirectoryReadException,_wrap_new_DirectoryReadException, swig_delete_DirectoryReadException, swig_Mezzanine_DirectoryReadException_methods, swig_Mezzanine_DirectoryReadException_attributes, swig_Mezzanine_DirectoryReadException_bases, swig_Mezzanine_DirectoryReadException_base_names };

static int _wrap_new_DirectoryWriteException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::DirectoryWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryWriteException::DirectoryWriteException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::DirectoryWriteException *)new Mezzanine::DirectoryWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryWriteException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::DirectoryWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryWriteException::DirectoryWriteException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::DirectoryWriteException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::DirectoryWriteException *)new Mezzanine::DirectoryWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryWriteException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_DirectoryWriteException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_DirectoryWriteException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_DirectoryWriteException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::DirectoryWriteException::DirectoryWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::DirectoryWriteException::DirectoryWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_DirectoryWriteException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::DirectoryWriteException *arg1 = (Mezzanine::DirectoryWriteException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::DirectoryWriteException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::DirectoryWriteException::GetExceptionCode",1,"Mezzanine::DirectoryWriteException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__DirectoryWriteException,0))){
    SWIG_fail_ptr("DirectoryWriteException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__DirectoryWriteException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::DirectoryWriteException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DirectoryWriteException(void *obj) {
Mezzanine::DirectoryWriteException *arg1 = (Mezzanine::DirectoryWriteException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_DirectoryWriteException_methods[] = {
    {"GetExceptionCode", _wrap_DirectoryWriteException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_DirectoryWriteException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_DirectoryWriteException_bases[] = {0,0};
static const char *swig_Mezzanine_DirectoryWriteException_base_names[] = {"Mezzanine::DirectoryException *",0};
static swig_lua_class _wrap_class_Mezzanine_DirectoryWriteException = { "DirectoryWriteException", &SWIGTYPE_p_Mezzanine__DirectoryWriteException,_wrap_new_DirectoryWriteException, swig_delete_DirectoryWriteException, swig_Mezzanine_DirectoryWriteException_methods, swig_Mezzanine_DirectoryWriteException_attributes, swig_Mezzanine_DirectoryWriteException_bases, swig_Mezzanine_DirectoryWriteException_base_names };

static int _wrap_new_DirectoryNotFoundException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::DirectoryNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::DirectoryNotFoundException *)new Mezzanine::DirectoryNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryNotFoundException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::DirectoryNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::DirectoryNotFoundException *)new Mezzanine::DirectoryNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryNotFoundException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_DirectoryNotFoundException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_DirectoryNotFoundException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_DirectoryNotFoundException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::DirectoryNotFoundException::DirectoryNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_DirectoryNotFoundException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::DirectoryNotFoundException *arg1 = (Mezzanine::DirectoryNotFoundException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::DirectoryNotFoundException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::DirectoryNotFoundException::GetExceptionCode",1,"Mezzanine::DirectoryNotFoundException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__DirectoryNotFoundException,0))){
    SWIG_fail_ptr("DirectoryNotFoundException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__DirectoryNotFoundException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::DirectoryNotFoundException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DirectoryNotFoundException(void *obj) {
Mezzanine::DirectoryNotFoundException *arg1 = (Mezzanine::DirectoryNotFoundException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_DirectoryNotFoundException_methods[] = {
    {"GetExceptionCode", _wrap_DirectoryNotFoundException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_DirectoryNotFoundException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_DirectoryNotFoundException_bases[] = {0,0};
static const char *swig_Mezzanine_DirectoryNotFoundException_base_names[] = {"Mezzanine::DirectoryException *",0};
static swig_lua_class _wrap_class_Mezzanine_DirectoryNotFoundException = { "DirectoryNotFoundException", &SWIGTYPE_p_Mezzanine__DirectoryNotFoundException,_wrap_new_DirectoryNotFoundException, swig_delete_DirectoryNotFoundException, swig_Mezzanine_DirectoryNotFoundException_methods, swig_Mezzanine_DirectoryNotFoundException_attributes, swig_Mezzanine_DirectoryNotFoundException_bases, swig_Mezzanine_DirectoryNotFoundException_base_names };

static int _wrap_new_DirectoryPermissionException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::DirectoryPermissionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::DirectoryPermissionException *)new Mezzanine::DirectoryPermissionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryPermissionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryPermissionException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::DirectoryPermissionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::DirectoryPermissionException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::DirectoryPermissionException *)new Mezzanine::DirectoryPermissionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__DirectoryPermissionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_DirectoryPermissionException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_DirectoryPermissionException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_DirectoryPermissionException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_DirectoryPermissionException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::DirectoryPermissionException::DirectoryPermissionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::DirectoryPermissionException::DirectoryPermissionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_DirectoryPermissionException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::DirectoryPermissionException *arg1 = (Mezzanine::DirectoryPermissionException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::DirectoryPermissionException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::DirectoryPermissionException::GetExceptionCode",1,"Mezzanine::DirectoryPermissionException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__DirectoryPermissionException,0))){
    SWIG_fail_ptr("DirectoryPermissionException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__DirectoryPermissionException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::DirectoryPermissionException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DirectoryPermissionException(void *obj) {
Mezzanine::DirectoryPermissionException *arg1 = (Mezzanine::DirectoryPermissionException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_DirectoryPermissionException_methods[] = {
    {"GetExceptionCode", _wrap_DirectoryPermissionException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_DirectoryPermissionException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_DirectoryPermissionException_bases[] = {0,0};
static const char *swig_Mezzanine_DirectoryPermissionException_base_names[] = {"Mezzanine::DirectoryException *",0};
static swig_lua_class _wrap_class_Mezzanine_DirectoryPermissionException = { "DirectoryPermissionException", &SWIGTYPE_p_Mezzanine__DirectoryPermissionException,_wrap_new_DirectoryPermissionException, swig_delete_DirectoryPermissionException, swig_Mezzanine_DirectoryPermissionException_methods, swig_Mezzanine_DirectoryPermissionException_attributes, swig_Mezzanine_DirectoryPermissionException_bases, swig_Mezzanine_DirectoryPermissionException_base_names };

static int _wrap_new_NetworkException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NetworkException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkException::NetworkException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NetworkException *)new Mezzanine::NetworkException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NetworkException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkException::NetworkException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NetworkException::NetworkException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NetworkException *)new Mezzanine::NetworkException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NetworkException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NetworkException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NetworkException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NetworkException::NetworkException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NetworkException::NetworkException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NetworkException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NetworkException *arg1 = (Mezzanine::NetworkException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NetworkException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NetworkException::GetExceptionCode",1,"Mezzanine::NetworkException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NetworkException,0))){
    SWIG_fail_ptr("NetworkException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NetworkException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NetworkException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NetworkException(void *obj) {
Mezzanine::NetworkException *arg1 = (Mezzanine::NetworkException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NetworkException_methods[] = {
    {"GetExceptionCode", _wrap_NetworkException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NetworkException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NetworkException_bases[] = {0,0};
static const char *swig_Mezzanine_NetworkException_base_names[] = {"Mezzanine::IOException *",0};
static swig_lua_class _wrap_class_Mezzanine_NetworkException = { "NetworkException", &SWIGTYPE_p_Mezzanine__NetworkException,_wrap_new_NetworkException, swig_delete_NetworkException, swig_Mezzanine_NetworkException_methods, swig_Mezzanine_NetworkException_attributes, swig_Mezzanine_NetworkException_bases, swig_Mezzanine_NetworkException_base_names };

static int _wrap_new_NetworkReadException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NetworkReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkReadException::NetworkReadException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NetworkReadException *)new Mezzanine::NetworkReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkReadException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NetworkReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkReadException::NetworkReadException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NetworkReadException::NetworkReadException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NetworkReadException *)new Mezzanine::NetworkReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkReadException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NetworkReadException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NetworkReadException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NetworkReadException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NetworkReadException::NetworkReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NetworkReadException::NetworkReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NetworkReadException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NetworkReadException *arg1 = (Mezzanine::NetworkReadException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NetworkReadException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NetworkReadException::GetExceptionCode",1,"Mezzanine::NetworkReadException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NetworkReadException,0))){
    SWIG_fail_ptr("NetworkReadException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NetworkReadException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NetworkReadException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NetworkReadException(void *obj) {
Mezzanine::NetworkReadException *arg1 = (Mezzanine::NetworkReadException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NetworkReadException_methods[] = {
    {"GetExceptionCode", _wrap_NetworkReadException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NetworkReadException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NetworkReadException_bases[] = {0,0};
static const char *swig_Mezzanine_NetworkReadException_base_names[] = {"Mezzanine::NetworkException *",0};
static swig_lua_class _wrap_class_Mezzanine_NetworkReadException = { "NetworkReadException", &SWIGTYPE_p_Mezzanine__NetworkReadException,_wrap_new_NetworkReadException, swig_delete_NetworkReadException, swig_Mezzanine_NetworkReadException_methods, swig_Mezzanine_NetworkReadException_attributes, swig_Mezzanine_NetworkReadException_bases, swig_Mezzanine_NetworkReadException_base_names };

static int _wrap_new_NetworkWriteException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NetworkWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkWriteException::NetworkWriteException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NetworkWriteException *)new Mezzanine::NetworkWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkWriteException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NetworkWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkWriteException::NetworkWriteException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NetworkWriteException::NetworkWriteException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NetworkWriteException *)new Mezzanine::NetworkWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkWriteException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NetworkWriteException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NetworkWriteException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NetworkWriteException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NetworkWriteException::NetworkWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NetworkWriteException::NetworkWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NetworkWriteException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NetworkWriteException *arg1 = (Mezzanine::NetworkWriteException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NetworkWriteException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NetworkWriteException::GetExceptionCode",1,"Mezzanine::NetworkWriteException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NetworkWriteException,0))){
    SWIG_fail_ptr("NetworkWriteException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NetworkWriteException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NetworkWriteException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NetworkWriteException(void *obj) {
Mezzanine::NetworkWriteException *arg1 = (Mezzanine::NetworkWriteException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NetworkWriteException_methods[] = {
    {"GetExceptionCode", _wrap_NetworkWriteException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NetworkWriteException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NetworkWriteException_bases[] = {0,0};
static const char *swig_Mezzanine_NetworkWriteException_base_names[] = {"Mezzanine::NetworkException *",0};
static swig_lua_class _wrap_class_Mezzanine_NetworkWriteException = { "NetworkWriteException", &SWIGTYPE_p_Mezzanine__NetworkWriteException,_wrap_new_NetworkWriteException, swig_delete_NetworkWriteException, swig_Mezzanine_NetworkWriteException_methods, swig_Mezzanine_NetworkWriteException_attributes, swig_Mezzanine_NetworkWriteException_bases, swig_Mezzanine_NetworkWriteException_base_names };

static int _wrap_new_NetworkNotFoundException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NetworkNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NetworkNotFoundException *)new Mezzanine::NetworkNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkNotFoundException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NetworkNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::NetworkNotFoundException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NetworkNotFoundException *)new Mezzanine::NetworkNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkNotFoundException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NetworkNotFoundException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NetworkNotFoundException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NetworkNotFoundException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NetworkNotFoundException::NetworkNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NetworkNotFoundException::NetworkNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NetworkNotFoundException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NetworkNotFoundException *arg1 = (Mezzanine::NetworkNotFoundException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NetworkNotFoundException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NetworkNotFoundException::GetExceptionCode",1,"Mezzanine::NetworkNotFoundException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NetworkNotFoundException,0))){
    SWIG_fail_ptr("NetworkNotFoundException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NetworkNotFoundException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NetworkNotFoundException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NetworkNotFoundException(void *obj) {
Mezzanine::NetworkNotFoundException *arg1 = (Mezzanine::NetworkNotFoundException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NetworkNotFoundException_methods[] = {
    {"GetExceptionCode", _wrap_NetworkNotFoundException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NetworkNotFoundException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NetworkNotFoundException_bases[] = {0,0};
static const char *swig_Mezzanine_NetworkNotFoundException_base_names[] = {"Mezzanine::NetworkException *",0};
static swig_lua_class _wrap_class_Mezzanine_NetworkNotFoundException = { "NetworkNotFoundException", &SWIGTYPE_p_Mezzanine__NetworkNotFoundException,_wrap_new_NetworkNotFoundException, swig_delete_NetworkNotFoundException, swig_Mezzanine_NetworkNotFoundException_methods, swig_Mezzanine_NetworkNotFoundException_attributes, swig_Mezzanine_NetworkNotFoundException_bases, swig_Mezzanine_NetworkNotFoundException_base_names };

static int _wrap_new_NetworkURLException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NetworkURLException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkURLException::NetworkURLException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NetworkURLException *)new Mezzanine::NetworkURLException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkURLException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkURLException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NetworkURLException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkURLException::NetworkURLException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NetworkURLException::NetworkURLException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NetworkURLException *)new Mezzanine::NetworkURLException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkURLException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkURLException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NetworkURLException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NetworkURLException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NetworkURLException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NetworkURLException::NetworkURLException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NetworkURLException::NetworkURLException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NetworkURLException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NetworkURLException *arg1 = (Mezzanine::NetworkURLException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NetworkURLException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NetworkURLException::GetExceptionCode",1,"Mezzanine::NetworkURLException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NetworkURLException,0))){
    SWIG_fail_ptr("NetworkURLException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NetworkURLException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NetworkURLException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NetworkURLException(void *obj) {
Mezzanine::NetworkURLException *arg1 = (Mezzanine::NetworkURLException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NetworkURLException_methods[] = {
    {"GetExceptionCode", _wrap_NetworkURLException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NetworkURLException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NetworkURLException_bases[] = {0,0};
static const char *swig_Mezzanine_NetworkURLException_base_names[] = {"Mezzanine::NetworkException *",0};
static swig_lua_class _wrap_class_Mezzanine_NetworkURLException = { "NetworkURLException", &SWIGTYPE_p_Mezzanine__NetworkURLException,_wrap_new_NetworkURLException, swig_delete_NetworkURLException, swig_Mezzanine_NetworkURLException_methods, swig_Mezzanine_NetworkURLException_attributes, swig_Mezzanine_NetworkURLException_bases, swig_Mezzanine_NetworkURLException_base_names };

static int _wrap_new_NetworkPermissionException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NetworkPermissionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkPermissionException::NetworkPermissionException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NetworkPermissionException *)new Mezzanine::NetworkPermissionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkPermissionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkPermissionException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NetworkPermissionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NetworkPermissionException::NetworkPermissionException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::NetworkPermissionException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NetworkPermissionException *)new Mezzanine::NetworkPermissionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NetworkPermissionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NetworkPermissionException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NetworkPermissionException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NetworkPermissionException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NetworkPermissionException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NetworkPermissionException::NetworkPermissionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NetworkPermissionException::NetworkPermissionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NetworkPermissionException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NetworkPermissionException *arg1 = (Mezzanine::NetworkPermissionException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NetworkPermissionException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NetworkPermissionException::GetExceptionCode",1,"Mezzanine::NetworkPermissionException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NetworkPermissionException,0))){
    SWIG_fail_ptr("NetworkPermissionException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NetworkPermissionException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NetworkPermissionException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NetworkPermissionException(void *obj) {
Mezzanine::NetworkPermissionException *arg1 = (Mezzanine::NetworkPermissionException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NetworkPermissionException_methods[] = {
    {"GetExceptionCode", _wrap_NetworkPermissionException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NetworkPermissionException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NetworkPermissionException_bases[] = {0,0};
static const char *swig_Mezzanine_NetworkPermissionException_base_names[] = {"Mezzanine::NetworkException *",0};
static swig_lua_class _wrap_class_Mezzanine_NetworkPermissionException = { "NetworkPermissionException", &SWIGTYPE_p_Mezzanine__NetworkPermissionException,_wrap_new_NetworkPermissionException, swig_delete_NetworkPermissionException, swig_Mezzanine_NetworkPermissionException_methods, swig_Mezzanine_NetworkPermissionException_attributes, swig_Mezzanine_NetworkPermissionException_bases, swig_Mezzanine_NetworkPermissionException_base_names };

static int _wrap_new_IOWriteException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::IOWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::IOWriteException::IOWriteException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::IOWriteException *)new Mezzanine::IOWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__IOWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_IOWriteException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::IOWriteException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::IOWriteException::IOWriteException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::IOWriteException::IOWriteException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::IOWriteException *)new Mezzanine::IOWriteException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__IOWriteException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_IOWriteException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_IOWriteException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_IOWriteException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_IOWriteException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::IOWriteException::IOWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::IOWriteException::IOWriteException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_IOWriteException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::IOWriteException *arg1 = (Mezzanine::IOWriteException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::IOWriteException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::IOWriteException::GetExceptionCode",1,"Mezzanine::IOWriteException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__IOWriteException,0))){
    SWIG_fail_ptr("IOWriteException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__IOWriteException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::IOWriteException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_IOWriteException(void *obj) {
Mezzanine::IOWriteException *arg1 = (Mezzanine::IOWriteException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_IOWriteException_methods[] = {
    {"GetExceptionCode", _wrap_IOWriteException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_IOWriteException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_IOWriteException_bases[] = {0,0};
static const char *swig_Mezzanine_IOWriteException_base_names[] = {"Mezzanine::IOException *",0};
static swig_lua_class _wrap_class_Mezzanine_IOWriteException = { "IOWriteException", &SWIGTYPE_p_Mezzanine__IOWriteException,_wrap_new_IOWriteException, swig_delete_IOWriteException, swig_Mezzanine_IOWriteException_methods, swig_Mezzanine_IOWriteException_attributes, swig_Mezzanine_IOWriteException_bases, swig_Mezzanine_IOWriteException_base_names };

static int _wrap_new_IOReadException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::IOReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::IOReadException::IOReadException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::IOReadException *)new Mezzanine::IOReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__IOReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_IOReadException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::IOReadException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::IOReadException::IOReadException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::IOReadException::IOReadException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::IOReadException *)new Mezzanine::IOReadException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__IOReadException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_IOReadException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_IOReadException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_IOReadException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_IOReadException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::IOReadException::IOReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::IOReadException::IOReadException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_IOReadException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::IOReadException *arg1 = (Mezzanine::IOReadException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::IOReadException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::IOReadException::GetExceptionCode",1,"Mezzanine::IOReadException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__IOReadException,0))){
    SWIG_fail_ptr("IOReadException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__IOReadException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::IOReadException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_IOReadException(void *obj) {
Mezzanine::IOReadException *arg1 = (Mezzanine::IOReadException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_IOReadException_methods[] = {
    {"GetExceptionCode", _wrap_IOReadException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_IOReadException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_IOReadException_bases[] = {0,0};
static const char *swig_Mezzanine_IOReadException_base_names[] = {"Mezzanine::IOException *",0};
static swig_lua_class _wrap_class_Mezzanine_IOReadException = { "IOReadException", &SWIGTYPE_p_Mezzanine__IOReadException,_wrap_new_IOReadException, swig_delete_IOReadException, swig_Mezzanine_IOReadException_methods, swig_Mezzanine_IOReadException_attributes, swig_Mezzanine_IOReadException_bases, swig_Mezzanine_IOReadException_base_names };

static int _wrap_new_InstanceIdentityException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InstanceIdentityException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityException::InstanceIdentityException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InstanceIdentityException *)new Mezzanine::InstanceIdentityException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InstanceIdentityException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityException::InstanceIdentityException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::InstanceIdentityException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InstanceIdentityException *)new Mezzanine::InstanceIdentityException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InstanceIdentityException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InstanceIdentityException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InstanceIdentityException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InstanceIdentityException::InstanceIdentityException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InstanceIdentityException::InstanceIdentityException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InstanceIdentityException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InstanceIdentityException *arg1 = (Mezzanine::InstanceIdentityException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityException::GetExceptionCode",1,"Mezzanine::InstanceIdentityException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InstanceIdentityException,0))){
    SWIG_fail_ptr("InstanceIdentityException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InstanceIdentityException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InstanceIdentityException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InstanceIdentityException(void *obj) {
Mezzanine::InstanceIdentityException *arg1 = (Mezzanine::InstanceIdentityException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InstanceIdentityException_methods[] = {
    {"GetExceptionCode", _wrap_InstanceIdentityException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InstanceIdentityException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InstanceIdentityException_bases[] = {0,0};
static const char *swig_Mezzanine_InstanceIdentityException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_InstanceIdentityException = { "InstanceIdentityException", &SWIGTYPE_p_Mezzanine__InstanceIdentityException,_wrap_new_InstanceIdentityException, swig_delete_InstanceIdentityException, swig_Mezzanine_InstanceIdentityException_methods, swig_Mezzanine_InstanceIdentityException_attributes, swig_Mezzanine_InstanceIdentityException_bases, swig_Mezzanine_InstanceIdentityException_base_names };

static int _wrap_new_InstanceIdentityInvalidException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InstanceIdentityInvalidException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InstanceIdentityInvalidException *)new Mezzanine::InstanceIdentityInvalidException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityInvalidException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityInvalidException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InstanceIdentityInvalidException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InstanceIdentityInvalidException *)new Mezzanine::InstanceIdentityInvalidException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityInvalidException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityInvalidException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InstanceIdentityInvalidException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InstanceIdentityInvalidException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InstanceIdentityInvalidException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InstanceIdentityInvalidException::InstanceIdentityInvalidException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InstanceIdentityInvalidException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InstanceIdentityInvalidException *arg1 = (Mezzanine::InstanceIdentityInvalidException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityInvalidException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityInvalidException::GetExceptionCode",1,"Mezzanine::InstanceIdentityInvalidException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InstanceIdentityInvalidException,0))){
    SWIG_fail_ptr("InstanceIdentityInvalidException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InstanceIdentityInvalidException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InstanceIdentityInvalidException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InstanceIdentityInvalidException(void *obj) {
Mezzanine::InstanceIdentityInvalidException *arg1 = (Mezzanine::InstanceIdentityInvalidException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InstanceIdentityInvalidException_methods[] = {
    {"GetExceptionCode", _wrap_InstanceIdentityInvalidException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InstanceIdentityInvalidException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InstanceIdentityInvalidException_bases[] = {0,0};
static const char *swig_Mezzanine_InstanceIdentityInvalidException_base_names[] = {"Mezzanine::InstanceIdentityException *",0};
static swig_lua_class _wrap_class_Mezzanine_InstanceIdentityInvalidException = { "InstanceIdentityInvalidException", &SWIGTYPE_p_Mezzanine__InstanceIdentityInvalidException,_wrap_new_InstanceIdentityInvalidException, swig_delete_InstanceIdentityInvalidException, swig_Mezzanine_InstanceIdentityInvalidException_methods, swig_Mezzanine_InstanceIdentityInvalidException_attributes, swig_Mezzanine_InstanceIdentityInvalidException_bases, swig_Mezzanine_InstanceIdentityInvalidException_base_names };

static int _wrap_new_InstanceIdentityNotFoundException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InstanceIdentityNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InstanceIdentityNotFoundException *)new Mezzanine::InstanceIdentityNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityNotFoundException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InstanceIdentityNotFoundException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InstanceIdentityNotFoundException *)new Mezzanine::InstanceIdentityNotFoundException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityNotFoundException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityNotFoundException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InstanceIdentityNotFoundException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InstanceIdentityNotFoundException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InstanceIdentityNotFoundException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InstanceIdentityNotFoundException::InstanceIdentityNotFoundException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InstanceIdentityNotFoundException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InstanceIdentityNotFoundException *arg1 = (Mezzanine::InstanceIdentityNotFoundException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityNotFoundException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityNotFoundException::GetExceptionCode",1,"Mezzanine::InstanceIdentityNotFoundException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InstanceIdentityNotFoundException,0))){
    SWIG_fail_ptr("InstanceIdentityNotFoundException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InstanceIdentityNotFoundException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InstanceIdentityNotFoundException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InstanceIdentityNotFoundException(void *obj) {
Mezzanine::InstanceIdentityNotFoundException *arg1 = (Mezzanine::InstanceIdentityNotFoundException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InstanceIdentityNotFoundException_methods[] = {
    {"GetExceptionCode", _wrap_InstanceIdentityNotFoundException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InstanceIdentityNotFoundException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InstanceIdentityNotFoundException_bases[] = {0,0};
static const char *swig_Mezzanine_InstanceIdentityNotFoundException_base_names[] = {"Mezzanine::InstanceIdentityException *",0};
static swig_lua_class _wrap_class_Mezzanine_InstanceIdentityNotFoundException = { "InstanceIdentityNotFoundException", &SWIGTYPE_p_Mezzanine__InstanceIdentityNotFoundException,_wrap_new_InstanceIdentityNotFoundException, swig_delete_InstanceIdentityNotFoundException, swig_Mezzanine_InstanceIdentityNotFoundException_methods, swig_Mezzanine_InstanceIdentityNotFoundException_attributes, swig_Mezzanine_InstanceIdentityNotFoundException_bases, swig_Mezzanine_InstanceIdentityNotFoundException_base_names };

static int _wrap_new_InstanceIdentityDuplicateException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InstanceIdentityDuplicateException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InstanceIdentityDuplicateException *)new Mezzanine::InstanceIdentityDuplicateException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityDuplicateException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityDuplicateException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InstanceIdentityDuplicateException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InstanceIdentityDuplicateException *)new Mezzanine::InstanceIdentityDuplicateException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InstanceIdentityDuplicateException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InstanceIdentityDuplicateException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InstanceIdentityDuplicateException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InstanceIdentityDuplicateException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InstanceIdentityDuplicateException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InstanceIdentityDuplicateException::InstanceIdentityDuplicateException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InstanceIdentityDuplicateException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InstanceIdentityDuplicateException *arg1 = (Mezzanine::InstanceIdentityDuplicateException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InstanceIdentityDuplicateException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InstanceIdentityDuplicateException::GetExceptionCode",1,"Mezzanine::InstanceIdentityDuplicateException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InstanceIdentityDuplicateException,0))){
    SWIG_fail_ptr("InstanceIdentityDuplicateException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InstanceIdentityDuplicateException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InstanceIdentityDuplicateException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InstanceIdentityDuplicateException(void *obj) {
Mezzanine::InstanceIdentityDuplicateException *arg1 = (Mezzanine::InstanceIdentityDuplicateException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InstanceIdentityDuplicateException_methods[] = {
    {"GetExceptionCode", _wrap_InstanceIdentityDuplicateException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InstanceIdentityDuplicateException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InstanceIdentityDuplicateException_bases[] = {0,0};
static const char *swig_Mezzanine_InstanceIdentityDuplicateException_base_names[] = {"Mezzanine::InstanceIdentityException *",0};
static swig_lua_class _wrap_class_Mezzanine_InstanceIdentityDuplicateException = { "InstanceIdentityDuplicateException", &SWIGTYPE_p_Mezzanine__InstanceIdentityDuplicateException,_wrap_new_InstanceIdentityDuplicateException, swig_delete_InstanceIdentityDuplicateException, swig_Mezzanine_InstanceIdentityDuplicateException_methods, swig_Mezzanine_InstanceIdentityDuplicateException_attributes, swig_Mezzanine_InstanceIdentityDuplicateException_bases, swig_Mezzanine_InstanceIdentityDuplicateException_base_names };

static int _wrap_new_MemoryManagementException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::MemoryManagementException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::MemoryManagementException::MemoryManagementException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::MemoryManagementException *)new Mezzanine::MemoryManagementException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__MemoryManagementException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MemoryManagementException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::MemoryManagementException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::MemoryManagementException::MemoryManagementException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::MemoryManagementException::MemoryManagementException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::MemoryManagementException *)new Mezzanine::MemoryManagementException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__MemoryManagementException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MemoryManagementException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_MemoryManagementException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_MemoryManagementException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_MemoryManagementException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::MemoryManagementException::MemoryManagementException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::MemoryManagementException::MemoryManagementException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_MemoryManagementException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::MemoryManagementException *arg1 = (Mezzanine::MemoryManagementException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::MemoryManagementException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::MemoryManagementException::GetExceptionCode",1,"Mezzanine::MemoryManagementException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__MemoryManagementException,0))){
    SWIG_fail_ptr("MemoryManagementException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__MemoryManagementException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::MemoryManagementException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_MemoryManagementException(void *obj) {
Mezzanine::MemoryManagementException *arg1 = (Mezzanine::MemoryManagementException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_MemoryManagementException_methods[] = {
    {"GetExceptionCode", _wrap_MemoryManagementException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_MemoryManagementException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_MemoryManagementException_bases[] = {0,0};
static const char *swig_Mezzanine_MemoryManagementException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_MemoryManagementException = { "MemoryManagementException", &SWIGTYPE_p_Mezzanine__MemoryManagementException,_wrap_new_MemoryManagementException, swig_delete_MemoryManagementException, swig_Mezzanine_MemoryManagementException_methods, swig_Mezzanine_MemoryManagementException_attributes, swig_Mezzanine_MemoryManagementException_bases, swig_Mezzanine_MemoryManagementException_base_names };

static int _wrap_new_OutOfMemoryException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::OutOfMemoryException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::OutOfMemoryException::OutOfMemoryException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::OutOfMemoryException *)new Mezzanine::OutOfMemoryException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__OutOfMemoryException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_OutOfMemoryException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::OutOfMemoryException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::OutOfMemoryException::OutOfMemoryException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::OutOfMemoryException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::OutOfMemoryException *)new Mezzanine::OutOfMemoryException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__OutOfMemoryException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_OutOfMemoryException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_OutOfMemoryException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_OutOfMemoryException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_OutOfMemoryException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::OutOfMemoryException::OutOfMemoryException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::OutOfMemoryException::OutOfMemoryException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_OutOfMemoryException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::OutOfMemoryException *arg1 = (Mezzanine::OutOfMemoryException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::OutOfMemoryException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::OutOfMemoryException::GetExceptionCode",1,"Mezzanine::OutOfMemoryException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__OutOfMemoryException,0))){
    SWIG_fail_ptr("OutOfMemoryException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__OutOfMemoryException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::OutOfMemoryException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_OutOfMemoryException(void *obj) {
Mezzanine::OutOfMemoryException *arg1 = (Mezzanine::OutOfMemoryException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_OutOfMemoryException_methods[] = {
    {"GetExceptionCode", _wrap_OutOfMemoryException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_OutOfMemoryException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_OutOfMemoryException_bases[] = {0,0};
static const char *swig_Mezzanine_OutOfMemoryException_base_names[] = {"Mezzanine::MemoryManagementException *",0};
static swig_lua_class _wrap_class_Mezzanine_OutOfMemoryException = { "OutOfMemoryException", &SWIGTYPE_p_Mezzanine__OutOfMemoryException,_wrap_new_OutOfMemoryException, swig_delete_OutOfMemoryException, swig_Mezzanine_OutOfMemoryException_methods, swig_Mezzanine_OutOfMemoryException_attributes, swig_Mezzanine_OutOfMemoryException_bases, swig_Mezzanine_OutOfMemoryException_base_names };

static int _wrap_new_MemoryOutOfBoundsException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::MemoryOutOfBoundsException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::MemoryOutOfBoundsException *)new Mezzanine::MemoryOutOfBoundsException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__MemoryOutOfBoundsException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MemoryOutOfBoundsException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::MemoryOutOfBoundsException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::MemoryOutOfBoundsException *)new Mezzanine::MemoryOutOfBoundsException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__MemoryOutOfBoundsException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MemoryOutOfBoundsException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_MemoryOutOfBoundsException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_MemoryOutOfBoundsException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_MemoryOutOfBoundsException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::MemoryOutOfBoundsException::MemoryOutOfBoundsException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_MemoryOutOfBoundsException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::MemoryOutOfBoundsException *arg1 = (Mezzanine::MemoryOutOfBoundsException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::MemoryOutOfBoundsException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::MemoryOutOfBoundsException::GetExceptionCode",1,"Mezzanine::MemoryOutOfBoundsException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__MemoryOutOfBoundsException,0))){
    SWIG_fail_ptr("MemoryOutOfBoundsException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__MemoryOutOfBoundsException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::MemoryOutOfBoundsException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_MemoryOutOfBoundsException(void *obj) {
Mezzanine::MemoryOutOfBoundsException *arg1 = (Mezzanine::MemoryOutOfBoundsException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_MemoryOutOfBoundsException_methods[] = {
    {"GetExceptionCode", _wrap_MemoryOutOfBoundsException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_MemoryOutOfBoundsException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_MemoryOutOfBoundsException_bases[] = {0,0};
static const char *swig_Mezzanine_MemoryOutOfBoundsException_base_names[] = {"Mezzanine::MemoryManagementException *",0};
static swig_lua_class _wrap_class_Mezzanine_MemoryOutOfBoundsException = { "MemoryOutOfBoundsException", &SWIGTYPE_p_Mezzanine__MemoryOutOfBoundsException,_wrap_new_MemoryOutOfBoundsException, swig_delete_MemoryOutOfBoundsException, swig_Mezzanine_MemoryOutOfBoundsException_methods, swig_Mezzanine_MemoryOutOfBoundsException_attributes, swig_Mezzanine_MemoryOutOfBoundsException_bases, swig_Mezzanine_MemoryOutOfBoundsException_base_names };

static int _wrap_new_SyntaxErrorException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::SyntaxErrorException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorException::SyntaxErrorException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::SyntaxErrorException *)new Mezzanine::SyntaxErrorException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::SyntaxErrorException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorException::SyntaxErrorException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::SyntaxErrorException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::SyntaxErrorException *)new Mezzanine::SyntaxErrorException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_SyntaxErrorException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_SyntaxErrorException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SyntaxErrorException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::SyntaxErrorException::SyntaxErrorException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::SyntaxErrorException::SyntaxErrorException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_SyntaxErrorException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::SyntaxErrorException *arg1 = (Mezzanine::SyntaxErrorException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorException::GetExceptionCode",1,"Mezzanine::SyntaxErrorException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__SyntaxErrorException,0))){
    SWIG_fail_ptr("SyntaxErrorException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__SyntaxErrorException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::SyntaxErrorException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SyntaxErrorException(void *obj) {
Mezzanine::SyntaxErrorException *arg1 = (Mezzanine::SyntaxErrorException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_SyntaxErrorException_methods[] = {
    {"GetExceptionCode", _wrap_SyntaxErrorException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_SyntaxErrorException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_SyntaxErrorException_bases[] = {0,0};
static const char *swig_Mezzanine_SyntaxErrorException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_SyntaxErrorException = { "SyntaxErrorException", &SWIGTYPE_p_Mezzanine__SyntaxErrorException,_wrap_new_SyntaxErrorException, swig_delete_SyntaxErrorException, swig_Mezzanine_SyntaxErrorException_methods, swig_Mezzanine_SyntaxErrorException_attributes, swig_Mezzanine_SyntaxErrorException_bases, swig_Mezzanine_SyntaxErrorException_base_names };

static int _wrap_new_SyntaxErrorXMLException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::SyntaxErrorXMLException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::SyntaxErrorXMLException *)new Mezzanine::SyntaxErrorXMLException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorXMLException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorXMLException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::SyntaxErrorXMLException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::SyntaxErrorXMLException *)new Mezzanine::SyntaxErrorXMLException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorXMLException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorXMLException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_SyntaxErrorXMLException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_SyntaxErrorXMLException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SyntaxErrorXMLException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::SyntaxErrorXMLException::SyntaxErrorXMLException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_SyntaxErrorXMLException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::SyntaxErrorXMLException *arg1 = (Mezzanine::SyntaxErrorXMLException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorXMLException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorXMLException::GetExceptionCode",1,"Mezzanine::SyntaxErrorXMLException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__SyntaxErrorXMLException,0))){
    SWIG_fail_ptr("SyntaxErrorXMLException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__SyntaxErrorXMLException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::SyntaxErrorXMLException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SyntaxErrorXMLException(void *obj) {
Mezzanine::SyntaxErrorXMLException *arg1 = (Mezzanine::SyntaxErrorXMLException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_SyntaxErrorXMLException_methods[] = {
    {"GetExceptionCode", _wrap_SyntaxErrorXMLException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_SyntaxErrorXMLException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_SyntaxErrorXMLException_bases[] = {0,0};
static const char *swig_Mezzanine_SyntaxErrorXMLException_base_names[] = {"Mezzanine::SyntaxErrorException *",0};
static swig_lua_class _wrap_class_Mezzanine_SyntaxErrorXMLException = { "SyntaxErrorXMLException", &SWIGTYPE_p_Mezzanine__SyntaxErrorXMLException,_wrap_new_SyntaxErrorXMLException, swig_delete_SyntaxErrorXMLException, swig_Mezzanine_SyntaxErrorXMLException_methods, swig_Mezzanine_SyntaxErrorXMLException_attributes, swig_Mezzanine_SyntaxErrorXMLException_bases, swig_Mezzanine_SyntaxErrorXMLException_base_names };

static int _wrap_new_SyntaxErrorXPathException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::SyntaxErrorXPathException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::SyntaxErrorXPathException *)new Mezzanine::SyntaxErrorXPathException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorXPathException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorXPathException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::SyntaxErrorXPathException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::SyntaxErrorXPathException *)new Mezzanine::SyntaxErrorXPathException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorXPathException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorXPathException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_SyntaxErrorXPathException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_SyntaxErrorXPathException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SyntaxErrorXPathException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::SyntaxErrorXPathException::SyntaxErrorXPathException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_SyntaxErrorXPathException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::SyntaxErrorXPathException *arg1 = (Mezzanine::SyntaxErrorXPathException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorXPathException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorXPathException::GetExceptionCode",1,"Mezzanine::SyntaxErrorXPathException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__SyntaxErrorXPathException,0))){
    SWIG_fail_ptr("SyntaxErrorXPathException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__SyntaxErrorXPathException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::SyntaxErrorXPathException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SyntaxErrorXPathException(void *obj) {
Mezzanine::SyntaxErrorXPathException *arg1 = (Mezzanine::SyntaxErrorXPathException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_SyntaxErrorXPathException_methods[] = {
    {"GetExceptionCode", _wrap_SyntaxErrorXPathException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_SyntaxErrorXPathException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_SyntaxErrorXPathException_bases[] = {0,0};
static const char *swig_Mezzanine_SyntaxErrorXPathException_base_names[] = {"Mezzanine::SyntaxErrorException *",0};
static swig_lua_class _wrap_class_Mezzanine_SyntaxErrorXPathException = { "SyntaxErrorXPathException", &SWIGTYPE_p_Mezzanine__SyntaxErrorXPathException,_wrap_new_SyntaxErrorXPathException, swig_delete_SyntaxErrorXPathException, swig_Mezzanine_SyntaxErrorXPathException_methods, swig_Mezzanine_SyntaxErrorXPathException_attributes, swig_Mezzanine_SyntaxErrorXPathException_bases, swig_Mezzanine_SyntaxErrorXPathException_base_names };

static int _wrap_new_SyntaxErrorLuaException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::SyntaxErrorLuaException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::SyntaxErrorLuaException *)new Mezzanine::SyntaxErrorLuaException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorLuaException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorLuaException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::SyntaxErrorLuaException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::SyntaxErrorLuaException *)new Mezzanine::SyntaxErrorLuaException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__SyntaxErrorLuaException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SyntaxErrorLuaException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_SyntaxErrorLuaException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_SyntaxErrorLuaException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SyntaxErrorLuaException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::SyntaxErrorLuaException::SyntaxErrorLuaException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_SyntaxErrorLuaException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::SyntaxErrorLuaException *arg1 = (Mezzanine::SyntaxErrorLuaException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::SyntaxErrorLuaException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::SyntaxErrorLuaException::GetExceptionCode",1,"Mezzanine::SyntaxErrorLuaException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__SyntaxErrorLuaException,0))){
    SWIG_fail_ptr("SyntaxErrorLuaException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__SyntaxErrorLuaException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::SyntaxErrorLuaException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SyntaxErrorLuaException(void *obj) {
Mezzanine::SyntaxErrorLuaException *arg1 = (Mezzanine::SyntaxErrorLuaException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_SyntaxErrorLuaException_methods[] = {
    {"GetExceptionCode", _wrap_SyntaxErrorLuaException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_SyntaxErrorLuaException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_SyntaxErrorLuaException_bases[] = {0,0};
static const char *swig_Mezzanine_SyntaxErrorLuaException_base_names[] = {"Mezzanine::SyntaxErrorException *",0};
static swig_lua_class _wrap_class_Mezzanine_SyntaxErrorLuaException = { "SyntaxErrorLuaException", &SWIGTYPE_p_Mezzanine__SyntaxErrorLuaException,_wrap_new_SyntaxErrorLuaException, swig_delete_SyntaxErrorLuaException, swig_Mezzanine_SyntaxErrorLuaException_methods, swig_Mezzanine_SyntaxErrorLuaException_attributes, swig_Mezzanine_SyntaxErrorLuaException_bases, swig_Mezzanine_SyntaxErrorLuaException_base_names };

static int _wrap_new_ScriptException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ScriptException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptException::ScriptException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ScriptException *)new Mezzanine::ScriptException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ScriptException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptException::ScriptException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ScriptException::ScriptException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ScriptException *)new Mezzanine::ScriptException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ScriptException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ScriptException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ScriptException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ScriptException::ScriptException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ScriptException::ScriptException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ScriptException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ScriptException *arg1 = (Mezzanine::ScriptException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ScriptException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ScriptException::GetExceptionCode",1,"Mezzanine::ScriptException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ScriptException,0))){
    SWIG_fail_ptr("ScriptException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ScriptException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ScriptException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ScriptException(void *obj) {
Mezzanine::ScriptException *arg1 = (Mezzanine::ScriptException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ScriptException_methods[] = {
    {"GetExceptionCode", _wrap_ScriptException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ScriptException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ScriptException_bases[] = {0,0};
static const char *swig_Mezzanine_ScriptException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_ScriptException = { "ScriptException", &SWIGTYPE_p_Mezzanine__ScriptException,_wrap_new_ScriptException, swig_delete_ScriptException, swig_Mezzanine_ScriptException_methods, swig_Mezzanine_ScriptException_attributes, swig_Mezzanine_ScriptException_bases, swig_Mezzanine_ScriptException_base_names };

static int _wrap_new_ScriptLuaException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ScriptLuaException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaException::ScriptLuaException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ScriptLuaException *)new Mezzanine::ScriptLuaException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ScriptLuaException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaException::ScriptLuaException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaException::ScriptLuaException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ScriptLuaException *)new Mezzanine::ScriptLuaException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ScriptLuaException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ScriptLuaException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ScriptLuaException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ScriptLuaException::ScriptLuaException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ScriptLuaException::ScriptLuaException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ScriptLuaException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ScriptLuaException *arg1 = (Mezzanine::ScriptLuaException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaException::GetExceptionCode",1,"Mezzanine::ScriptLuaException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ScriptLuaException,0))){
    SWIG_fail_ptr("ScriptLuaException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ScriptLuaException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ScriptLuaException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ScriptLuaException(void *obj) {
Mezzanine::ScriptLuaException *arg1 = (Mezzanine::ScriptLuaException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ScriptLuaException_methods[] = {
    {"GetExceptionCode", _wrap_ScriptLuaException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ScriptLuaException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ScriptLuaException_bases[] = {0,0};
static const char *swig_Mezzanine_ScriptLuaException_base_names[] = {"Mezzanine::ScriptException *",0};
static swig_lua_class _wrap_class_Mezzanine_ScriptLuaException = { "ScriptLuaException", &SWIGTYPE_p_Mezzanine__ScriptLuaException,_wrap_new_ScriptLuaException, swig_delete_ScriptLuaException, swig_Mezzanine_ScriptLuaException_methods, swig_Mezzanine_ScriptLuaException_attributes, swig_Mezzanine_ScriptLuaException_bases, swig_Mezzanine_ScriptLuaException_base_names };

static int _wrap_new_ScriptLuaYieldException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ScriptLuaYieldException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ScriptLuaYieldException *)new Mezzanine::ScriptLuaYieldException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaYieldException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaYieldException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ScriptLuaYieldException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ScriptLuaYieldException *)new Mezzanine::ScriptLuaYieldException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaYieldException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaYieldException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ScriptLuaYieldException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ScriptLuaYieldException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ScriptLuaYieldException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ScriptLuaYieldException::ScriptLuaYieldException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ScriptLuaYieldException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ScriptLuaYieldException *arg1 = (Mezzanine::ScriptLuaYieldException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaYieldException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaYieldException::GetExceptionCode",1,"Mezzanine::ScriptLuaYieldException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ScriptLuaYieldException,0))){
    SWIG_fail_ptr("ScriptLuaYieldException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ScriptLuaYieldException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ScriptLuaYieldException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ScriptLuaYieldException(void *obj) {
Mezzanine::ScriptLuaYieldException *arg1 = (Mezzanine::ScriptLuaYieldException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ScriptLuaYieldException_methods[] = {
    {"GetExceptionCode", _wrap_ScriptLuaYieldException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ScriptLuaYieldException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ScriptLuaYieldException_bases[] = {0,0};
static const char *swig_Mezzanine_ScriptLuaYieldException_base_names[] = {"Mezzanine::ScriptLuaException *",0};
static swig_lua_class _wrap_class_Mezzanine_ScriptLuaYieldException = { "ScriptLuaYieldException", &SWIGTYPE_p_Mezzanine__ScriptLuaYieldException,_wrap_new_ScriptLuaYieldException, swig_delete_ScriptLuaYieldException, swig_Mezzanine_ScriptLuaYieldException_methods, swig_Mezzanine_ScriptLuaYieldException_attributes, swig_Mezzanine_ScriptLuaYieldException_bases, swig_Mezzanine_ScriptLuaYieldException_base_names };

static int _wrap_new_ScriptLuaRuntimeException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ScriptLuaRuntimeException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ScriptLuaRuntimeException *)new Mezzanine::ScriptLuaRuntimeException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaRuntimeException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaRuntimeException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ScriptLuaRuntimeException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ScriptLuaRuntimeException *)new Mezzanine::ScriptLuaRuntimeException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaRuntimeException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaRuntimeException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ScriptLuaRuntimeException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ScriptLuaRuntimeException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ScriptLuaRuntimeException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ScriptLuaRuntimeException::ScriptLuaRuntimeException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ScriptLuaRuntimeException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ScriptLuaRuntimeException *arg1 = (Mezzanine::ScriptLuaRuntimeException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaRuntimeException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaRuntimeException::GetExceptionCode",1,"Mezzanine::ScriptLuaRuntimeException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ScriptLuaRuntimeException,0))){
    SWIG_fail_ptr("ScriptLuaRuntimeException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ScriptLuaRuntimeException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ScriptLuaRuntimeException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ScriptLuaRuntimeException(void *obj) {
Mezzanine::ScriptLuaRuntimeException *arg1 = (Mezzanine::ScriptLuaRuntimeException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ScriptLuaRuntimeException_methods[] = {
    {"GetExceptionCode", _wrap_ScriptLuaRuntimeException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ScriptLuaRuntimeException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ScriptLuaRuntimeException_bases[] = {0,0};
static const char *swig_Mezzanine_ScriptLuaRuntimeException_base_names[] = {"Mezzanine::ScriptLuaException *",0};
static swig_lua_class _wrap_class_Mezzanine_ScriptLuaRuntimeException = { "ScriptLuaRuntimeException", &SWIGTYPE_p_Mezzanine__ScriptLuaRuntimeException,_wrap_new_ScriptLuaRuntimeException, swig_delete_ScriptLuaRuntimeException, swig_Mezzanine_ScriptLuaRuntimeException_methods, swig_Mezzanine_ScriptLuaRuntimeException_attributes, swig_Mezzanine_ScriptLuaRuntimeException_bases, swig_Mezzanine_ScriptLuaRuntimeException_base_names };

static int _wrap_new_ScriptLuaErrErrException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ScriptLuaErrErrException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ScriptLuaErrErrException *)new Mezzanine::ScriptLuaErrErrException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaErrErrException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaErrErrException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ScriptLuaErrErrException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ScriptLuaErrErrException *)new Mezzanine::ScriptLuaErrErrException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ScriptLuaErrErrException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ScriptLuaErrErrException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ScriptLuaErrErrException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ScriptLuaErrErrException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ScriptLuaErrErrException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ScriptLuaErrErrException::ScriptLuaErrErrException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ScriptLuaErrErrException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ScriptLuaErrErrException *arg1 = (Mezzanine::ScriptLuaErrErrException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ScriptLuaErrErrException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ScriptLuaErrErrException::GetExceptionCode",1,"Mezzanine::ScriptLuaErrErrException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ScriptLuaErrErrException,0))){
    SWIG_fail_ptr("ScriptLuaErrErrException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ScriptLuaErrErrException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ScriptLuaErrErrException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ScriptLuaErrErrException(void *obj) {
Mezzanine::ScriptLuaErrErrException *arg1 = (Mezzanine::ScriptLuaErrErrException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ScriptLuaErrErrException_methods[] = {
    {"GetExceptionCode", _wrap_ScriptLuaErrErrException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ScriptLuaErrErrException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ScriptLuaErrErrException_bases[] = {0,0};
static const char *swig_Mezzanine_ScriptLuaErrErrException_base_names[] = {"Mezzanine::ScriptLuaException *",0};
static swig_lua_class _wrap_class_Mezzanine_ScriptLuaErrErrException = { "ScriptLuaErrErrException", &SWIGTYPE_p_Mezzanine__ScriptLuaErrErrException,_wrap_new_ScriptLuaErrErrException, swig_delete_ScriptLuaErrErrException, swig_Mezzanine_ScriptLuaErrErrException_methods, swig_Mezzanine_ScriptLuaErrErrException_attributes, swig_Mezzanine_ScriptLuaErrErrException_bases, swig_Mezzanine_ScriptLuaErrErrException_base_names };

static int _wrap_new_ParametersException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ParametersException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ParametersException::ParametersException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ParametersException *)new Mezzanine::ParametersException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ParametersException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ParametersException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ParametersException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ParametersException::ParametersException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ParametersException::ParametersException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ParametersException *)new Mezzanine::ParametersException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ParametersException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ParametersException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ParametersException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ParametersException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ParametersException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ParametersException::ParametersException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ParametersException::ParametersException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ParametersException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ParametersException *arg1 = (Mezzanine::ParametersException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ParametersException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ParametersException::GetExceptionCode",1,"Mezzanine::ParametersException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ParametersException,0))){
    SWIG_fail_ptr("ParametersException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ParametersException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ParametersException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ParametersException(void *obj) {
Mezzanine::ParametersException *arg1 = (Mezzanine::ParametersException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ParametersException_methods[] = {
    {"GetExceptionCode", _wrap_ParametersException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ParametersException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ParametersException_bases[] = {0,0};
static const char *swig_Mezzanine_ParametersException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_ParametersException = { "ParametersException", &SWIGTYPE_p_Mezzanine__ParametersException,_wrap_new_ParametersException, swig_delete_ParametersException, swig_Mezzanine_ParametersException_methods, swig_Mezzanine_ParametersException_attributes, swig_Mezzanine_ParametersException_bases, swig_Mezzanine_ParametersException_base_names };

static int _wrap_new_ParametersCastException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ParametersCastException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ParametersCastException::ParametersCastException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ParametersCastException *)new Mezzanine::ParametersCastException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ParametersCastException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ParametersCastException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ParametersCastException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ParametersCastException::ParametersCastException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ParametersCastException::ParametersCastException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ParametersCastException *)new Mezzanine::ParametersCastException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ParametersCastException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ParametersCastException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ParametersCastException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ParametersCastException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ParametersCastException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ParametersCastException::ParametersCastException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ParametersCastException::ParametersCastException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ParametersCastException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ParametersCastException *arg1 = (Mezzanine::ParametersCastException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ParametersCastException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ParametersCastException::GetExceptionCode",1,"Mezzanine::ParametersCastException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ParametersCastException,0))){
    SWIG_fail_ptr("ParametersCastException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ParametersCastException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ParametersCastException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ParametersCastException(void *obj) {
Mezzanine::ParametersCastException *arg1 = (Mezzanine::ParametersCastException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ParametersCastException_methods[] = {
    {"GetExceptionCode", _wrap_ParametersCastException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ParametersCastException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ParametersCastException_bases[] = {0,0};
static const char *swig_Mezzanine_ParametersCastException_base_names[] = {"Mezzanine::ParametersException *",0};
static swig_lua_class _wrap_class_Mezzanine_ParametersCastException = { "ParametersCastException", &SWIGTYPE_p_Mezzanine__ParametersCastException,_wrap_new_ParametersCastException, swig_delete_ParametersCastException, swig_Mezzanine_ParametersCastException_methods, swig_Mezzanine_ParametersCastException_attributes, swig_Mezzanine_ParametersCastException_bases, swig_Mezzanine_ParametersCastException_base_names };

static int _wrap_new_ParametersRangeException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ParametersRangeException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ParametersRangeException::ParametersRangeException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ParametersRangeException *)new Mezzanine::ParametersRangeException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ParametersRangeException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ParametersRangeException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ParametersRangeException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ParametersRangeException::ParametersRangeException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ParametersRangeException::ParametersRangeException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ParametersRangeException *)new Mezzanine::ParametersRangeException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ParametersRangeException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ParametersRangeException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ParametersRangeException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ParametersRangeException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ParametersRangeException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ParametersRangeException::ParametersRangeException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ParametersRangeException::ParametersRangeException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ParametersRangeException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ParametersRangeException *arg1 = (Mezzanine::ParametersRangeException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ParametersRangeException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ParametersRangeException::GetExceptionCode",1,"Mezzanine::ParametersRangeException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ParametersRangeException,0))){
    SWIG_fail_ptr("ParametersRangeException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ParametersRangeException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ParametersRangeException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ParametersRangeException(void *obj) {
Mezzanine::ParametersRangeException *arg1 = (Mezzanine::ParametersRangeException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ParametersRangeException_methods[] = {
    {"GetExceptionCode", _wrap_ParametersRangeException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ParametersRangeException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ParametersRangeException_bases[] = {0,0};
static const char *swig_Mezzanine_ParametersRangeException_base_names[] = {"Mezzanine::ParametersException *",0};
static swig_lua_class _wrap_class_Mezzanine_ParametersRangeException = { "ParametersRangeException", &SWIGTYPE_p_Mezzanine__ParametersRangeException,_wrap_new_ParametersRangeException, swig_delete_ParametersRangeException, swig_Mezzanine_ParametersRangeException_methods, swig_Mezzanine_ParametersRangeException_attributes, swig_Mezzanine_ParametersRangeException_bases, swig_Mezzanine_ParametersRangeException_base_names };

static int _wrap_new_ArithmeticException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::ArithmeticException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ArithmeticException::ArithmeticException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::ArithmeticException *)new Mezzanine::ArithmeticException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ArithmeticException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ArithmeticException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::ArithmeticException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::ArithmeticException::ArithmeticException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::ArithmeticException::ArithmeticException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::ArithmeticException *)new Mezzanine::ArithmeticException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__ArithmeticException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ArithmeticException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ArithmeticException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_ArithmeticException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ArithmeticException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::ArithmeticException::ArithmeticException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::ArithmeticException::ArithmeticException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_ArithmeticException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::ArithmeticException *arg1 = (Mezzanine::ArithmeticException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::ArithmeticException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::ArithmeticException::GetExceptionCode",1,"Mezzanine::ArithmeticException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__ArithmeticException,0))){
    SWIG_fail_ptr("ArithmeticException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__ArithmeticException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::ArithmeticException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ArithmeticException(void *obj) {
Mezzanine::ArithmeticException *arg1 = (Mezzanine::ArithmeticException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_ArithmeticException_methods[] = {
    {"GetExceptionCode", _wrap_ArithmeticException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_ArithmeticException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_ArithmeticException_bases[] = {0,0};
static const char *swig_Mezzanine_ArithmeticException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_ArithmeticException = { "ArithmeticException", &SWIGTYPE_p_Mezzanine__ArithmeticException,_wrap_new_ArithmeticException, swig_delete_ArithmeticException, swig_Mezzanine_ArithmeticException_methods, swig_Mezzanine_ArithmeticException_attributes, swig_Mezzanine_ArithmeticException_bases, swig_Mezzanine_ArithmeticException_base_names };

static int _wrap_new_InvalidVersionException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InvalidVersionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InvalidVersionException::InvalidVersionException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InvalidVersionException *)new Mezzanine::InvalidVersionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InvalidVersionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InvalidVersionException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InvalidVersionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InvalidVersionException::InvalidVersionException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InvalidVersionException::InvalidVersionException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InvalidVersionException *)new Mezzanine::InvalidVersionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InvalidVersionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InvalidVersionException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InvalidVersionException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InvalidVersionException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InvalidVersionException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InvalidVersionException::InvalidVersionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InvalidVersionException::InvalidVersionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InvalidVersionException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InvalidVersionException *arg1 = (Mezzanine::InvalidVersionException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InvalidVersionException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InvalidVersionException::GetExceptionCode",1,"Mezzanine::InvalidVersionException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InvalidVersionException,0))){
    SWIG_fail_ptr("InvalidVersionException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InvalidVersionException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InvalidVersionException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InvalidVersionException(void *obj) {
Mezzanine::InvalidVersionException *arg1 = (Mezzanine::InvalidVersionException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InvalidVersionException_methods[] = {
    {"GetExceptionCode", _wrap_InvalidVersionException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InvalidVersionException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InvalidVersionException_bases[] = {0,0};
static const char *swig_Mezzanine_InvalidVersionException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_InvalidVersionException = { "InvalidVersionException", &SWIGTYPE_p_Mezzanine__InvalidVersionException,_wrap_new_InvalidVersionException, swig_delete_InvalidVersionException, swig_Mezzanine_InvalidVersionException_methods, swig_Mezzanine_InvalidVersionException_attributes, swig_Mezzanine_InvalidVersionException_bases, swig_Mezzanine_InvalidVersionException_base_names };

static int _wrap_new_InvalidStateException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InvalidStateException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InvalidStateException::InvalidStateException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InvalidStateException *)new Mezzanine::InvalidStateException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InvalidStateException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InvalidStateException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InvalidStateException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InvalidStateException::InvalidStateException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InvalidStateException::InvalidStateException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InvalidStateException *)new Mezzanine::InvalidStateException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InvalidStateException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InvalidStateException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InvalidStateException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InvalidStateException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InvalidStateException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InvalidStateException::InvalidStateException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InvalidStateException::InvalidStateException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InvalidStateException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InvalidStateException *arg1 = (Mezzanine::InvalidStateException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InvalidStateException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InvalidStateException::GetExceptionCode",1,"Mezzanine::InvalidStateException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InvalidStateException,0))){
    SWIG_fail_ptr("InvalidStateException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InvalidStateException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InvalidStateException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InvalidStateException(void *obj) {
Mezzanine::InvalidStateException *arg1 = (Mezzanine::InvalidStateException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InvalidStateException_methods[] = {
    {"GetExceptionCode", _wrap_InvalidStateException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InvalidStateException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InvalidStateException_bases[] = {0,0};
static const char *swig_Mezzanine_InvalidStateException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_InvalidStateException = { "InvalidStateException", &SWIGTYPE_p_Mezzanine__InvalidStateException,_wrap_new_InvalidStateException, swig_delete_InvalidStateException, swig_Mezzanine_InvalidStateException_methods, swig_Mezzanine_InvalidStateException_attributes, swig_Mezzanine_InvalidStateException_bases, swig_Mezzanine_InvalidStateException_base_names };

static int _wrap_new_RenderingAPIException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::RenderingAPIException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::RenderingAPIException::RenderingAPIException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::RenderingAPIException *)new Mezzanine::RenderingAPIException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__RenderingAPIException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RenderingAPIException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::RenderingAPIException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::RenderingAPIException::RenderingAPIException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::RenderingAPIException::RenderingAPIException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::RenderingAPIException *)new Mezzanine::RenderingAPIException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__RenderingAPIException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RenderingAPIException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_RenderingAPIException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_RenderingAPIException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_RenderingAPIException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::RenderingAPIException::RenderingAPIException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::RenderingAPIException::RenderingAPIException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_RenderingAPIException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::RenderingAPIException *arg1 = (Mezzanine::RenderingAPIException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::RenderingAPIException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::RenderingAPIException::GetExceptionCode",1,"Mezzanine::RenderingAPIException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__RenderingAPIException,0))){
    SWIG_fail_ptr("RenderingAPIException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__RenderingAPIException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::RenderingAPIException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_RenderingAPIException(void *obj) {
Mezzanine::RenderingAPIException *arg1 = (Mezzanine::RenderingAPIException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_RenderingAPIException_methods[] = {
    {"GetExceptionCode", _wrap_RenderingAPIException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_RenderingAPIException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_RenderingAPIException_bases[] = {0,0};
static const char *swig_Mezzanine_RenderingAPIException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_RenderingAPIException = { "RenderingAPIException", &SWIGTYPE_p_Mezzanine__RenderingAPIException,_wrap_new_RenderingAPIException, swig_delete_RenderingAPIException, swig_Mezzanine_RenderingAPIException_methods, swig_Mezzanine_RenderingAPIException_attributes, swig_Mezzanine_RenderingAPIException_bases, swig_Mezzanine_RenderingAPIException_base_names };

static int _wrap_new_RuntimeAssertionException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::RuntimeAssertionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::RuntimeAssertionException *)new Mezzanine::RuntimeAssertionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__RuntimeAssertionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RuntimeAssertionException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::RuntimeAssertionException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::RuntimeAssertionException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::RuntimeAssertionException *)new Mezzanine::RuntimeAssertionException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__RuntimeAssertionException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RuntimeAssertionException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_RuntimeAssertionException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_RuntimeAssertionException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_RuntimeAssertionException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::RuntimeAssertionException::RuntimeAssertionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::RuntimeAssertionException::RuntimeAssertionException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_RuntimeAssertionException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::RuntimeAssertionException *arg1 = (Mezzanine::RuntimeAssertionException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::RuntimeAssertionException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::RuntimeAssertionException::GetExceptionCode",1,"Mezzanine::RuntimeAssertionException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__RuntimeAssertionException,0))){
    SWIG_fail_ptr("RuntimeAssertionException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__RuntimeAssertionException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::RuntimeAssertionException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_RuntimeAssertionException(void *obj) {
Mezzanine::RuntimeAssertionException *arg1 = (Mezzanine::RuntimeAssertionException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_RuntimeAssertionException_methods[] = {
    {"GetExceptionCode", _wrap_RuntimeAssertionException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_RuntimeAssertionException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_RuntimeAssertionException_bases[] = {0,0};
static const char *swig_Mezzanine_RuntimeAssertionException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_RuntimeAssertionException = { "RuntimeAssertionException", &SWIGTYPE_p_Mezzanine__RuntimeAssertionException,_wrap_new_RuntimeAssertionException, swig_delete_RuntimeAssertionException, swig_Mezzanine_RuntimeAssertionException_methods, swig_Mezzanine_RuntimeAssertionException_attributes, swig_Mezzanine_RuntimeAssertionException_bases, swig_Mezzanine_RuntimeAssertionException_base_names };

static int _wrap_new_InternalException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InternalException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InternalException::InternalException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InternalException *)new Mezzanine::InternalException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InternalException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InternalException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InternalException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InternalException::InternalException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InternalException::InternalException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InternalException *)new Mezzanine::InternalException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InternalException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InternalException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InternalException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InternalException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InternalException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InternalException::InternalException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InternalException::InternalException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InternalException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InternalException *arg1 = (Mezzanine::InternalException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InternalException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InternalException::GetExceptionCode",1,"Mezzanine::InternalException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InternalException,0))){
    SWIG_fail_ptr("InternalException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InternalException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InternalException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InternalException(void *obj) {
Mezzanine::InternalException *arg1 = (Mezzanine::InternalException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InternalException_methods[] = {
    {"GetExceptionCode", _wrap_InternalException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InternalException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InternalException_bases[] = {0,0};
static const char *swig_Mezzanine_InternalException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_InternalException = { "InternalException", &SWIGTYPE_p_Mezzanine__InternalException,_wrap_new_InternalException, swig_delete_InternalException, swig_Mezzanine_InternalException_methods, swig_Mezzanine_InternalException_attributes, swig_Mezzanine_InternalException_bases, swig_Mezzanine_InternalException_base_names };

static int _wrap_new_NotImplementedException__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::NotImplementedException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NotImplementedException::NotImplementedException",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::NotImplementedException *)new Mezzanine::NotImplementedException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NotImplementedException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NotImplementedException__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::NotImplementedException *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::NotImplementedException::NotImplementedException",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::NotImplementedException::NotImplementedException",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::NotImplementedException *)new Mezzanine::NotImplementedException((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__NotImplementedException,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_NotImplementedException(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_NotImplementedException__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_NotImplementedException__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NotImplementedException'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::NotImplementedException::NotImplementedException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::NotImplementedException::NotImplementedException(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_NotImplementedException_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::NotImplementedException *arg1 = (Mezzanine::NotImplementedException *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::NotImplementedException::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::NotImplementedException::GetExceptionCode",1,"Mezzanine::NotImplementedException const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__NotImplementedException,0))){
    SWIG_fail_ptr("NotImplementedException_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__NotImplementedException);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::NotImplementedException const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_NotImplementedException(void *obj) {
Mezzanine::NotImplementedException *arg1 = (Mezzanine::NotImplementedException *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_NotImplementedException_methods[] = {
    {"GetExceptionCode", _wrap_NotImplementedException_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_NotImplementedException_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_NotImplementedException_bases[] = {0,0};
static const char *swig_Mezzanine_NotImplementedException_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_NotImplementedException = { "NotImplementedException", &SWIGTYPE_p_Mezzanine__NotImplementedException,_wrap_new_NotImplementedException, swig_delete_NotImplementedException, swig_Mezzanine_NotImplementedException_methods, swig_Mezzanine_NotImplementedException_attributes, swig_Mezzanine_NotImplementedException_bases, swig_Mezzanine_NotImplementedException_base_names };

static int _wrap_new_InvalidAssignment__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::String *arg4 = 0 ;
  Mezzanine::Whole *arg5 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::String temp4 ;
  Mezzanine::Whole temp5 ;
  Mezzanine::InvalidAssignment *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InvalidAssignment::InvalidAssignment",5,5)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",3,"Mezzanine::String const &");
  if(!lua_isstring(L,4)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",4,"Mezzanine::String const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",5,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4;
  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
  temp5=(Mezzanine::Whole)lua_tonumber(L,5); arg5=&temp5;
  result = (Mezzanine::InvalidAssignment *)new Mezzanine::InvalidAssignment((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::String const &)*arg4,(Mezzanine::Whole const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InvalidAssignment,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InvalidAssignment__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String *arg3 = 0 ;
  Mezzanine::Whole *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  Mezzanine::String temp3 ;
  Mezzanine::Whole temp4 ;
  Mezzanine::InvalidAssignment *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::InvalidAssignment::InvalidAssignment",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",2,"Mezzanine::String const &");
  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",3,"Mezzanine::String const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::InvalidAssignment::InvalidAssignment",4,"Mezzanine::Whole const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
  temp4=(Mezzanine::Whole)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::InvalidAssignment *)new Mezzanine::InvalidAssignment((Mezzanine::String const &)*arg1,(Mezzanine::String const &)*arg2,(Mezzanine::String const &)*arg3,(Mezzanine::Whole const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__InvalidAssignment,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_InvalidAssignment(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_InvalidAssignment__SWIG_1(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isstring(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isstring(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_InvalidAssignment__SWIG_0(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_InvalidAssignment'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::InvalidAssignment::InvalidAssignment(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n"
    "    Mezzanine::InvalidAssignment::InvalidAssignment(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_InvalidAssignment_GetExceptionCode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::InvalidAssignment *arg1 = (Mezzanine::InvalidAssignment *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::InvalidAssignment::GetExceptionCode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::InvalidAssignment::GetExceptionCode",1,"Mezzanine::InvalidAssignment const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__InvalidAssignment,0))){
    SWIG_fail_ptr("InvalidAssignment_GetExceptionCode",1,SWIGTYPE_p_Mezzanine__InvalidAssignment);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::InvalidAssignment const *)arg1)->GetExceptionCode();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_InvalidAssignment(void *obj) {
Mezzanine::InvalidAssignment *arg1 = (Mezzanine::InvalidAssignment *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_InvalidAssignment_methods[] = {
    {"GetExceptionCode", _wrap_InvalidAssignment_GetExceptionCode}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_InvalidAssignment_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_InvalidAssignment_bases[] = {0,0};
static const char *swig_Mezzanine_InvalidAssignment_base_names[] = {"Mezzanine::Exception *",0};
static swig_lua_class _wrap_class_Mezzanine_InvalidAssignment = { "InvalidAssignment", &SWIGTYPE_p_Mezzanine__InvalidAssignment,_wrap_new_InvalidAssignment, swig_delete_InvalidAssignment, swig_Mezzanine_InvalidAssignment_methods, swig_Mezzanine_InvalidAssignment_attributes, swig_Mezzanine_InvalidAssignment_bases, swig_Mezzanine_InvalidAssignment_base_names };

static int _wrap_SerializeError__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Boole arg3 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::SerializeError",3,3)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SerializeError",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SerializeError",2,"Mezzanine::String const &");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::SerializeError",3,"Mezzanine::Boole");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  arg3 = (lua_toboolean(L, 3)!=0);
  Mezzanine::SerializeError((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SerializeError__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::SerializeError",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::SerializeError",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::SerializeError",2,"Mezzanine::String const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  Mezzanine::SerializeError((std::string const &)*arg1,(std::string const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SerializeError(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        return _wrap_SerializeError__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isboolean(L,argv[2]);
        }
        if (_v) {
          return _wrap_SerializeError__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'SerializeError'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::SerializeError(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Boole)\n"
    "    Mezzanine::SerializeError(Mezzanine::String const &,Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_DeSerializeError__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::Boole arg3 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::DeSerializeError",3,3)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DeSerializeError",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DeSerializeError",2,"Mezzanine::String const &");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::DeSerializeError",3,"Mezzanine::Boole");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  arg3 = (lua_toboolean(L, 3)!=0);
  Mezzanine::DeSerializeError((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DeSerializeError__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String *arg2 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::String temp2 ;
  
  SWIG_check_num_args("Mezzanine::DeSerializeError",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::DeSerializeError",1,"Mezzanine::String const &");
  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::DeSerializeError",2,"Mezzanine::String const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
  Mezzanine::DeSerializeError((std::string const &)*arg1,(std::string const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DeSerializeError(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        return _wrap_DeSerializeError__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isstring(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isboolean(L,argv[2]);
        }
        if (_v) {
          return _wrap_DeSerializeError__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'DeSerializeError'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::DeSerializeError(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::Boole)\n"
    "    Mezzanine::DeSerializeError(Mezzanine::String const &,Mezzanine::String const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3_X_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::X",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::X",1,"Mezzanine::Vector3 *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::X",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_X_set",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->X = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_X_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::X",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::X",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_X_get",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real) ((arg1)->X);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Y_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Y",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Y",1,"Mezzanine::Vector3 *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Y",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Y_set",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->Y = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Y_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Y",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Y",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Y_get",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real) ((arg1)->Y);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Z_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Z",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Z",1,"Mezzanine::Vector3 *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Z",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Z_set",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->Z = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Z_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Z",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Z",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Z_get",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real) ((arg1)->Z);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetAxisValue(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetAxisValue",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetAxisValue",1,"Mezzanine::Vector3 const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::GetAxisValue",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetAxisValue",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Real)((Mezzanine::Vector3 const *)arg1)->GetAxisValue((Mezzanine::Whole const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Vector3",0,0)
  result = (Mezzanine::Vector3 *)new Mezzanine::Vector3();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Real temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Vector3",3,3)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",1,"Mezzanine::Real const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",3,"Mezzanine::Real const &");
  temp1=(Mezzanine::Real)lua_tonumber(L,1); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  result = (Mezzanine::Vector3 *)new Mezzanine::Vector3((Mezzanine::Real const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Vector3",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",1,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("new_Vector3",1,SWIGTYPE_p_Ogre__Vector3);
  }
  
  result = (Mezzanine::Vector3 *)new Mezzanine::Vector3((Ogre::Vector3 const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  btVector3 *arg1 = 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Vector3",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",1,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("new_Vector3",1,SWIGTYPE_p_btVector3);
  }
  
  result = (Mezzanine::Vector3 *)new Mezzanine::Vector3((btVector3 const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Vector3",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",1,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Vector3",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Vector3 *)new Mezzanine::Vector3((Mezzanine::Vector3 const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3__SWIG_5(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Vector3",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Vector3",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_Vector3",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Vector3 *)new Mezzanine::Vector3(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Vector3(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_Vector3__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Vector3__SWIG_2(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Vector3__SWIG_3(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Vector3__SWIG_4(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Vector3__SWIG_5(L);
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_new_Vector3__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Vector3'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::Vector3()\n"
    "    Mezzanine::Vector3::Vector3(Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::Real const &)\n"
    "    Mezzanine::Vector3::Vector3(Ogre::Vector3 const &)\n"
    "    Mezzanine::Vector3::Vector3(btVector3 const &)\n"
    "    Mezzanine::Vector3::Vector3(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Vector3::Vector3(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3_Unit_X(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Unit_X",0,0)
  result = Mezzanine::Vector3::Unit_X();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Unit_Y(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Unit_Y",0,0)
  result = Mezzanine::Vector3::Unit_Y();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Unit_Z(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Unit_Z",0,0)
  result = Mezzanine::Vector3::Unit_Z();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Neg_Unit_X(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Neg_Unit_X",0,0)
  result = Mezzanine::Vector3::Neg_Unit_X();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Neg_Unit_Y(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Neg_Unit_Y",0,0)
  result = Mezzanine::Vector3::Neg_Unit_Y();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Neg_Unit_Z(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Neg_Unit_Z",0,0)
  result = Mezzanine::Vector3::Neg_Unit_Z();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_UnitOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::StandardAxis arg1 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::UnitOnAxis",1,1)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Vector3::UnitOnAxis",1,"Mezzanine::StandardAxis");
  arg1 = (Mezzanine::StandardAxis)(int)lua_tonumber(L, 1);
  result = Mezzanine::Vector3::UnitOnAxis(arg1);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_IsStandardUnitAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::StandardAxis result;
  
  SWIG_check_num_args("Mezzanine::Vector3::IsStandardUnitAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::IsStandardUnitAxis",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_IsStandardUnitAxis",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::StandardAxis)((Mezzanine::Vector3 const *)arg1)->IsStandardUnitAxis();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___unm(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator -",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___unm",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (arg1)->operator -();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___mul__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator *",1,"Mezzanine::Vector3 const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator *",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___mul",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Vector3 const *)arg1)->operator *((Mezzanine::Real const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___div__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator /",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator /",1,"Mezzanine::Vector3 const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator /",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___div",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Vector3 const *)arg1)->operator /((Mezzanine::Real const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___eq__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator ==",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator ==",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___eq",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___eq",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Vector3 const *)arg1)->operator ==((Mezzanine::Vector3 const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___eq__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator ==",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator ==",2,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___eq",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("Vector3___eq",2,SWIGTYPE_p_btVector3);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Vector3 const *)arg1)->operator ==((btVector3 const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___eq__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator ==",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator ==",2,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___eq",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("Vector3___eq",2,SWIGTYPE_p_Ogre__Vector3);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Vector3 const *)arg1)->operator ==((Ogre::Vector3 const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___eq(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___eq__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___eq__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___eq__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Vector3___eq'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::operator ==(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Vector3::operator ==(btVector3 const &) const\n"
    "    Mezzanine::Vector3::operator ==(Ogre::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3___le(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator <=",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator <=",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator <=",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___le",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___le",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Vector3 const *)arg1)->operator <=((Mezzanine::Vector3 const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___add__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator +",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator +",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___add",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___add",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator +((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___sub__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator -",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator -",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___sub",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___sub",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator -((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___mul__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator *",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator *",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___mul",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___mul",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator *((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___div__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator /",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator /",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator /",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___div",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___div",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator /((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___add__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator +",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator +",2,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___add",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("Vector3___add",2,SWIGTYPE_p_btVector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator +((btVector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___sub__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator -",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator -",2,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___sub",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("Vector3___sub",2,SWIGTYPE_p_btVector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator -((btVector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___mul__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator *",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator *",2,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___mul",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("Vector3___mul",2,SWIGTYPE_p_btVector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator *((btVector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___div__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator /",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator /",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator /",2,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___div",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("Vector3___div",2,SWIGTYPE_p_btVector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator /((btVector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___add__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator +",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator +",2,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___add",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("Vector3___add",2,SWIGTYPE_p_Ogre__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator +((Ogre::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___add(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___add__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___add__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___add__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Vector3___add'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::operator +(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Vector3::operator +(btVector3 const &) const\n"
    "    Mezzanine::Vector3::operator +(Ogre::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3___sub__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator -",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator -",2,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___sub",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("Vector3___sub",2,SWIGTYPE_p_Ogre__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator -((Ogre::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___sub(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___sub__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___sub__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___sub__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Vector3___sub'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::operator -(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Vector3::operator -(btVector3 const &) const\n"
    "    Mezzanine::Vector3::operator -(Ogre::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3___mul__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator *",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator *",2,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___mul",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("Vector3___mul",2,SWIGTYPE_p_Ogre__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___mul(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___mul__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___mul__SWIG_2(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___mul__SWIG_3(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_Vector3___mul__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Vector3___mul'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::operator *(Mezzanine::Real const &) const\n"
    "    Mezzanine::Vector3::operator *(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Vector3::operator *(btVector3 const &) const\n"
    "    Mezzanine::Vector3::operator *(Ogre::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3___div__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::operator /",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::operator /",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::operator /",2,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___div",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("Vector3___div",2,SWIGTYPE_p_Ogre__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->operator /((Ogre::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___div(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___div__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___div__SWIG_2(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3___div__SWIG_3(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_Vector3___div__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Vector3___div'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::operator /(Mezzanine::Real const &) const\n"
    "    Mezzanine::Vector3::operator /(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Vector3::operator /(btVector3 const &) const\n"
    "    Mezzanine::Vector3::operator /(Ogre::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3_CrossProduct(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::CrossProduct",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::CrossProduct",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::CrossProduct",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_CrossProduct",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_CrossProduct",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->CrossProduct((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_DotProduct(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::DotProduct",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::DotProduct",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::DotProduct",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_DotProduct",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_DotProduct",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Vector3 const *)arg1)->DotProduct((Mezzanine::Vector3 const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Normalize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Normalize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Normalize",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Normalize",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Vector3 *) &(arg1)->Normalize();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetNormal(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetNormal",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetNormal",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetNormal",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->GetNormal();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetDirection(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetDirection",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetDirection",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::GetDirection",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetDirection",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetDirection",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->GetDirection((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Inverse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Inverse",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Inverse",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Inverse",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (arg1)->Inverse();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Reflect(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Reflect",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Reflect",1,"Mezzanine::Vector3 *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Reflect",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Reflect",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Reflect",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (arg1)->Reflect((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Distance(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Distance",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Distance",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Distance",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Distance",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Distance",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Vector3 const *)arg1)->Distance((Mezzanine::Vector3 const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_SquaredDistance(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::SquaredDistance",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::SquaredDistance",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::SquaredDistance",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_SquaredDistance",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_SquaredDistance",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Vector3 const *)arg1)->SquaredDistance((Mezzanine::Vector3 const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Length(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::Length",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Length",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Length",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Vector3 const *)arg1)->Length();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_SquaredLength(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Vector3::SquaredLength",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::SquaredLength",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_SquaredLength",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Vector3 const *)arg1)->SquaredLength();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_IsZeroLength(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Vector3::IsZeroLength",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::IsZeroLength",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_IsZeroLength",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Vector3 const *)arg1)->IsZeroLength();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetRotationToAxis__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetRotationToAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetRotationToAxis",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::GetRotationToAxis",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Vector3::GetRotationToAxis",3,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetRotationToAxis",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetRotationToAxis",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetRotationToAxis",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->GetRotationToAxis((Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetRotationToAxis__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetRotationToAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetRotationToAxis",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::GetRotationToAxis",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetRotationToAxis",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetRotationToAxis",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->GetRotationToAxis((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetRotationToAxis(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Vector3_GetRotationToAxis__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_Vector3_GetRotationToAxis__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Vector3_GetRotationToAxis'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Vector3::GetRotationToAxis(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Vector3::GetRotationToAxis(Mezzanine::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Vector3_Zero(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Zero",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Zero",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Zero",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Zero();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_SetValues(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Real *arg4 = 0 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Real temp4 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::SetValues",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::SetValues",1,"Mezzanine::Vector3 *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Vector3::SetValues",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Vector3::SetValues",3,"Mezzanine::Real const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Vector3::SetValues",4,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_SetValues",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  temp4=(Mezzanine::Real)lua_tonumber(L,4); arg4=&temp4;
  (arg1)->SetValues((Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,(Mezzanine::Real const &)*arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Ceil(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Ceil",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Ceil",1,"Mezzanine::Vector3 *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Ceil",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Ceil",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Ceil",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Vector3 *) &(arg1)->Ceil((Mezzanine::Vector3 const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_Floor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::Floor",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::Floor",1,"Mezzanine::Vector3 *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::Floor",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Floor",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_Floor",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Vector3 *) &(arg1)->Floor((Mezzanine::Vector3 const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetBulletVector3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetBulletVector3",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetBulletVector3",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetBulletVector3",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->GetBulletVector3();
  {
    btVector3 * resultptr = new btVector3((const btVector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_btVector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_ExtractBulletVector3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  btVector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::ExtractBulletVector3",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::ExtractBulletVector3",1,"Mezzanine::Vector3 *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::ExtractBulletVector3",2,"btVector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_ExtractBulletVector3",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("Vector3_ExtractBulletVector3",2,SWIGTYPE_p_btVector3);
  }
  
  (arg1)->ExtractBulletVector3((btVector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_GetOgreVector3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Vector3::GetOgreVector3",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::GetOgreVector3",1,"Mezzanine::Vector3 const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_GetOgreVector3",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Vector3 const *)arg1)->GetOgreVector3();
  {
    Ogre::Vector3 * resultptr = new Ogre::Vector3((const Ogre::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Ogre__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_ExtractOgreVector3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::ExtractOgreVector3",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::ExtractOgreVector3",1,"Mezzanine::Vector3 *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::ExtractOgreVector3",2,"Ogre::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_ExtractOgreVector3",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("Vector3_ExtractOgreVector3",2,SWIGTYPE_p_Ogre__Vector3);
  }
  
  (arg1)->ExtractOgreVector3((Ogre::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::ProtoSerialize",1,"Mezzanine::Vector3 const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Vector3_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Vector3 const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::ProtoDeSerialize",1,"Mezzanine::Vector3 *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Vector3::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Vector3_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Vector3::SerializableName",0,0)
  result = Mezzanine::Vector3::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Vector3___tostring(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) 0 ;
  char *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Vector3::__str__",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Vector3::__str__",1,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Vector3___tostring",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (char *)(arg1)->__str__();
  lua_pushstring(L,(const char *)result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Vector3(void *obj) {
Mezzanine::Vector3 *arg1 = (Mezzanine::Vector3 *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Vector3_methods[] = {
    {"GetAxisValue", _wrap_Vector3_GetAxisValue}, 
    {"IsStandardUnitAxis", _wrap_Vector3_IsStandardUnitAxis}, 
    {"__unm", _wrap_Vector3___unm}, 
    {"__eq", _wrap_Vector3___eq}, 
    {"__le", _wrap_Vector3___le}, 
    {"__add", _wrap_Vector3___add}, 
    {"__sub", _wrap_Vector3___sub}, 
    {"__mul", _wrap_Vector3___mul}, 
    {"__div", _wrap_Vector3___div}, 
    {"CrossProduct", _wrap_Vector3_CrossProduct}, 
    {"DotProduct", _wrap_Vector3_DotProduct}, 
    {"Normalize", _wrap_Vector3_Normalize}, 
    {"GetNormal", _wrap_Vector3_GetNormal}, 
    {"GetDirection", _wrap_Vector3_GetDirection}, 
    {"Inverse", _wrap_Vector3_Inverse}, 
    {"Reflect", _wrap_Vector3_Reflect}, 
    {"Distance", _wrap_Vector3_Distance}, 
    {"SquaredDistance", _wrap_Vector3_SquaredDistance}, 
    {"Length", _wrap_Vector3_Length}, 
    {"SquaredLength", _wrap_Vector3_SquaredLength}, 
    {"IsZeroLength", _wrap_Vector3_IsZeroLength}, 
    {"GetRotationToAxis", _wrap_Vector3_GetRotationToAxis}, 
    {"Zero", _wrap_Vector3_Zero}, 
    {"SetValues", _wrap_Vector3_SetValues}, 
    {"Ceil", _wrap_Vector3_Ceil}, 
    {"Floor", _wrap_Vector3_Floor}, 
    {"GetBulletVector3", _wrap_Vector3_GetBulletVector3}, 
    {"ExtractBulletVector3", _wrap_Vector3_ExtractBulletVector3}, 
    {"GetOgreVector3", _wrap_Vector3_GetOgreVector3}, 
    {"ExtractOgreVector3", _wrap_Vector3_ExtractOgreVector3}, 
    {"ProtoSerialize", _wrap_Vector3_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Vector3_ProtoDeSerialize}, 
    {"__tostring", _wrap_Vector3___tostring}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Vector3_attributes[] = {
    { "X", _wrap_Vector3_X_get, _wrap_Vector3_X_set},
    { "Y", _wrap_Vector3_Y_get, _wrap_Vector3_Y_set},
    { "Z", _wrap_Vector3_Z_get, _wrap_Vector3_Z_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Vector3_bases[] = {0};
static const char *swig_Mezzanine_Vector3_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Vector3 = { "Vector3", &SWIGTYPE_p_Mezzanine__Vector3,_wrap_new_Vector3, swig_delete_Vector3, swig_Mezzanine_Vector3_methods, swig_Mezzanine_Vector3_attributes, swig_Mezzanine_Vector3_bases, swig_Mezzanine_Vector3_base_names };

static int _wrap___add__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  btVector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator +",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator +",1,"btVector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator +",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("__add",1,SWIGTYPE_p_btVector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__add",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator +((btVector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___sub__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  btVector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator -",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator -",1,"btVector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator -",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("__sub",1,SWIGTYPE_p_btVector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__sub",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator -((btVector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___mul__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  btVector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator *",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator *",1,"btVector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator *",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("__mul",1,SWIGTYPE_p_btVector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__mul",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator *((btVector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___div__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  btVector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator /",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator /",1,"btVector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator /",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btVector3,0))){
    SWIG_fail_ptr("__div",1,SWIGTYPE_p_btVector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__div",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator /((btVector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___add__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator +",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator +",1,"Ogre::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator +",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("__add",1,SWIGTYPE_p_Ogre__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__add",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator +((Ogre::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___add(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___add__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___add__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function '__add'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::operator +(btVector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::operator +(Ogre::Vector3 const &,Mezzanine::Vector3 const &)\n");
  lua_error(L);return 0;
}


static int _wrap___sub__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator -",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator -",1,"Ogre::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator -",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("__sub",1,SWIGTYPE_p_Ogre__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__sub",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator -((Ogre::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___sub(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___sub__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___sub__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function '__sub'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::operator -(btVector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::operator -(Ogre::Vector3 const &,Mezzanine::Vector3 const &)\n");
  lua_error(L);return 0;
}


static int _wrap___mul__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator *",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator *",1,"Ogre::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator *",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("__mul",1,SWIGTYPE_p_Ogre__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__mul",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator *((Ogre::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___mul(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___mul__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___mul__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function '__mul'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::operator *(btVector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::operator *(Ogre::Vector3 const &,Mezzanine::Vector3 const &)\n");
  lua_error(L);return 0;
}


static int _wrap___div__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::operator /",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::operator /",1,"Ogre::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::operator /",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Vector3,0))){
    SWIG_fail_ptr("__div",1,SWIGTYPE_p_Ogre__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("__div",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = Mezzanine::operator /((Ogre::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap___div(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btVector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___div__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap___div__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function '__div'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::operator /(btVector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::operator /(Ogre::Vector3 const &,Mezzanine::Vector3 const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion_X_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::X",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::X",1,"Mezzanine::Quaternion *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::X",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_X_set",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->X = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_X_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::X",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::X",1,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_X_get",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real) ((arg1)->X);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_Y_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Y",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Y",1,"Mezzanine::Quaternion *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::Y",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_Y_set",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->Y = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_Y_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Y",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Y",1,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_Y_get",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real) ((arg1)->Y);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_Z_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Z",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Z",1,"Mezzanine::Quaternion *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::Z",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_Z_set",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->Z = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_Z_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Z",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Z",1,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_Z_get",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real) ((arg1)->Z);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_W_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::W",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::W",1,"Mezzanine::Quaternion *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::W",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_W_set",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->W = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_W_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::W",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::W",1,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_W_get",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real) ((arg1)->W);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",0,0)
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Real *arg4 = 0 ;
  Mezzanine::Real temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Real temp4 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",4,4)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"Mezzanine::Real const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",3,"Mezzanine::Real const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",4,"Mezzanine::Real const &");
  temp1=(Mezzanine::Real)lua_tonumber(L,1); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  temp4=(Mezzanine::Real)lua_tonumber(L,4); arg4=&temp4;
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((Mezzanine::Real const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,(Mezzanine::Real const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real temp1 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",2,2)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"Mezzanine::Real const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",2,"Mezzanine::Vector3 const &");
  temp1=(Mezzanine::Real)lua_tonumber(L,1); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((Mezzanine::Real const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Matrix3x3 *arg1 = 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"Mezzanine::Matrix3x3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Matrix3x3,0))){
    SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_Mezzanine__Matrix3x3);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((Mezzanine::Matrix3x3 const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",3,3)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",3,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Quaternion",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((Mezzanine::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_5(lua_State* L) {
  int SWIG_arg = 0;
  btQuaternion *arg1 = 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"btQuaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btQuaternion,0))){
    SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_btQuaternion);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((btQuaternion const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_6(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Quaternion *arg1 = 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"Ogre::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Quaternion,0))){
    SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_Ogre__Quaternion);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((Ogre::Quaternion const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_7(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((Mezzanine::Quaternion const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion__SWIG_8(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Quaternion",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Quaternion",1,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Quaternion *)new Mezzanine::Quaternion((XML::Node const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Quaternion(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_Quaternion__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Matrix3x3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Quaternion__SWIG_3(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btQuaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Quaternion__SWIG_5(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Quaternion__SWIG_6(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Quaternion__SWIG_7(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Quaternion__SWIG_8(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_Quaternion__SWIG_2(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_Quaternion__SWIG_4(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_Quaternion__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Quaternion'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::Quaternion()\n"
    "    Mezzanine::Quaternion::Quaternion(Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::Real const &)\n"
    "    Mezzanine::Quaternion::Quaternion(Mezzanine::Real const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Quaternion::Quaternion(Mezzanine::Matrix3x3 const &)\n"
    "    Mezzanine::Quaternion::Quaternion(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Quaternion::Quaternion(btQuaternion const &)\n"
    "    Mezzanine::Quaternion::Quaternion(Ogre::Quaternion const &)\n"
    "    Mezzanine::Quaternion::Quaternion(Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Quaternion::Quaternion(XML::Node const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion_SetIdentity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::SetIdentity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::SetIdentity",1,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_SetIdentity",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetIdentity();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_SetValues(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Real *arg4 = 0 ;
  Mezzanine::Real *arg5 = 0 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Real temp4 ;
  Mezzanine::Real temp5 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::SetValues",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::SetValues",1,"Mezzanine::Quaternion *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::SetValues",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Quaternion::SetValues",3,"Mezzanine::Real const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Quaternion::SetValues",4,"Mezzanine::Real const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Quaternion::SetValues",5,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_SetValues",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  temp4=(Mezzanine::Real)lua_tonumber(L,4); arg4=&temp4;
  temp5=(Mezzanine::Real)lua_tonumber(L,5); arg5=&temp5;
  (arg1)->SetValues((Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,(Mezzanine::Real const &)*arg4,(Mezzanine::Real const &)*arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_SetFromAxisAngle(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::SetFromAxisAngle",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxisAngle",1,"Mezzanine::Quaternion *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxisAngle",2,"Mezzanine::Real const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxisAngle",3,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_SetFromAxisAngle",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Quaternion_SetFromAxisAngle",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetFromAxisAngle((Mezzanine::Real const &)*arg2,(Mezzanine::Vector3 const &)*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_SetFromMatrix3x3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Matrix3x3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::SetFromMatrix3x3",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromMatrix3x3",1,"Mezzanine::Quaternion *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromMatrix3x3",2,"Mezzanine::Matrix3x3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_SetFromMatrix3x3",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Matrix3x3,0))){
    SWIG_fail_ptr("Quaternion_SetFromMatrix3x3",2,SWIGTYPE_p_Mezzanine__Matrix3x3);
  }
  
  (arg1)->SetFromMatrix3x3((Mezzanine::Matrix3x3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_SetFromAxes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Vector3 *arg4 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::SetFromAxes",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxes",1,"Mezzanine::Quaternion *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxes",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxes",3,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Quaternion::SetFromAxes",4,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_SetFromAxes",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Quaternion_SetFromAxes",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Quaternion_SetFromAxes",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Quaternion_SetFromAxes",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetFromAxes((Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3,(Mezzanine::Vector3 const &)*arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_DotProduct(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::DotProduct",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::DotProduct",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::DotProduct",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_DotProduct",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_DotProduct",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Quaternion const *)arg1)->DotProduct((Mezzanine::Quaternion const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_Length(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Length",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Length",1,"Mezzanine::Quaternion const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_Length",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Quaternion const *)arg1)->Length();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_LengthSqrd(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::LengthSqrd",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::LengthSqrd",1,"Mezzanine::Quaternion const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_LengthSqrd",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Quaternion const *)arg1)->LengthSqrd();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_Normalize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::Normalize",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::Normalize",1,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_Normalize",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Quaternion *) &(arg1)->Normalize();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetNormalizedCopy(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::GetNormalizedCopy",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::GetNormalizedCopy",1,"Mezzanine::Quaternion const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_GetNormalizedCopy",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->GetNormalizedCopy();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetInverse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::GetInverse",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::GetInverse",1,"Mezzanine::Quaternion const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_GetInverse",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->GetInverse();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetBulletQuaternion__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Boole arg2 ;
  btQuaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::GetBulletQuaternion",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::GetBulletQuaternion",1,"Mezzanine::Quaternion const *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::GetBulletQuaternion",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_GetBulletQuaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  result = ((Mezzanine::Quaternion const *)arg1)->GetBulletQuaternion(arg2);
  {
    btQuaternion * resultptr = new btQuaternion((const btQuaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_btQuaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetBulletQuaternion__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  btQuaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::GetBulletQuaternion",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::GetBulletQuaternion",1,"Mezzanine::Quaternion const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_GetBulletQuaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->GetBulletQuaternion();
  {
    btQuaternion * resultptr = new btQuaternion((const btQuaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_btQuaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetBulletQuaternion(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_Quaternion_GetBulletQuaternion__SWIG_1(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isboolean(L,argv[1]);
      }
      if (_v) {
        return _wrap_Quaternion_GetBulletQuaternion__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Quaternion_GetBulletQuaternion'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::GetBulletQuaternion(Mezzanine::Boole) const\n"
    "    Mezzanine::Quaternion::GetBulletQuaternion() const\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion_ExtractBulletQuaternion(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  btQuaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::ExtractBulletQuaternion",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::ExtractBulletQuaternion",1,"Mezzanine::Quaternion *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::ExtractBulletQuaternion",2,"btQuaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_ExtractBulletQuaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btQuaternion,0))){
    SWIG_fail_ptr("Quaternion_ExtractBulletQuaternion",2,SWIGTYPE_p_btQuaternion);
  }
  
  (arg1)->ExtractBulletQuaternion((btQuaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetOgreQuaternion__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Boole arg2 ;
  Ogre::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::GetOgreQuaternion",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::GetOgreQuaternion",1,"Mezzanine::Quaternion const *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::GetOgreQuaternion",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_GetOgreQuaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  result = ((Mezzanine::Quaternion const *)arg1)->GetOgreQuaternion(arg2);
  {
    Ogre::Quaternion * resultptr = new Ogre::Quaternion((const Ogre::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Ogre__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetOgreQuaternion__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Ogre::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::GetOgreQuaternion",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::GetOgreQuaternion",1,"Mezzanine::Quaternion const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_GetOgreQuaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->GetOgreQuaternion();
  {
    Ogre::Quaternion * resultptr = new Ogre::Quaternion((const Ogre::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Ogre__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_GetOgreQuaternion(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_Quaternion_GetOgreQuaternion__SWIG_1(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isboolean(L,argv[1]);
      }
      if (_v) {
        return _wrap_Quaternion_GetOgreQuaternion__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Quaternion_GetOgreQuaternion'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::GetOgreQuaternion(Mezzanine::Boole) const\n"
    "    Mezzanine::Quaternion::GetOgreQuaternion() const\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion_ExtractOgreQuaternion(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::ExtractOgreQuaternion",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::ExtractOgreQuaternion",1,"Mezzanine::Quaternion *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::ExtractOgreQuaternion",2,"Ogre::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_ExtractOgreQuaternion",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_ExtractOgreQuaternion",2,SWIGTYPE_p_Ogre__Quaternion);
  }
  
  (arg1)->ExtractOgreQuaternion((Ogre::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___mul__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",1,"Mezzanine::Quaternion const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Quaternion const *)arg1)->operator *((Mezzanine::Real const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___div(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator /",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator /",1,"Mezzanine::Quaternion const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator /",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Quaternion const *)arg1)->operator /((Mezzanine::Real const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___add__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator +",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator +",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___add",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___add",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator +((Mezzanine::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___add__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator +",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator +",2,"Ogre::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___add",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___add",2,SWIGTYPE_p_Ogre__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator +((Ogre::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___add__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  btQuaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator +",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator +",2,"btQuaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___add",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btQuaternion,0))){
    SWIG_fail_ptr("Quaternion___add",2,SWIGTYPE_p_btQuaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator +((btQuaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___add(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___add__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___add__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btQuaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___add__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Quaternion___add'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::operator +(Mezzanine::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator +(Ogre::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator +(btQuaternion const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion___sub__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator -",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator -",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___sub",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___sub",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator -((Mezzanine::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___sub__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator -",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator -",2,"Ogre::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___sub",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___sub",2,SWIGTYPE_p_Ogre__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator -((Ogre::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___sub__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  btQuaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator -",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator -",2,"btQuaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___sub",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btQuaternion,0))){
    SWIG_fail_ptr("Quaternion___sub",2,SWIGTYPE_p_btQuaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator -((btQuaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___sub(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___sub__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___sub__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btQuaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___sub__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Quaternion___sub'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::operator -(Mezzanine::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator -(Ogre::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator -(btQuaternion const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion___mul__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator *((Mezzanine::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___mul__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",2,"Ogre::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_Ogre__Quaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator *((Ogre::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___mul__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  btQuaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",2,"btQuaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btQuaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_btQuaternion);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator *((btQuaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___mul__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator *",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::Quaternion const *)arg1)->operator *((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___mul(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___mul__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___mul__SWIG_2(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btQuaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___mul__SWIG_3(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___mul__SWIG_4(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_Quaternion___mul__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Quaternion___mul'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::operator *(Mezzanine::Real const &) const\n"
    "    Mezzanine::Quaternion::operator *(Mezzanine::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator *(Ogre::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator *(btQuaternion const &) const\n"
    "    Mezzanine::Quaternion::operator *(Mezzanine::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion___eq__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator ==",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator ==",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___eq",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___eq",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Quaternion const *)arg1)->operator ==((Mezzanine::Quaternion const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___eq__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator ==",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator ==",2,"Ogre::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___eq",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___eq",2,SWIGTYPE_p_Ogre__Quaternion);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Quaternion const *)arg1)->operator ==((Ogre::Quaternion const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___eq__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  btQuaternion *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator ==",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator ==",2,"btQuaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___eq",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btQuaternion,0))){
    SWIG_fail_ptr("Quaternion___eq",2,SWIGTYPE_p_btQuaternion);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Quaternion const *)arg1)->operator ==((btQuaternion const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion___eq(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___eq__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Ogre__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___eq__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btQuaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Quaternion___eq__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Quaternion___eq'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Quaternion::operator ==(Mezzanine::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator ==(Ogre::Quaternion const &) const\n"
    "    Mezzanine::Quaternion::operator ==(btQuaternion const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Quaternion___le(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::operator <=",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::operator <=",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::operator <=",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___le",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion___le",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Quaternion const *)arg1)->operator <=((Mezzanine::Quaternion const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::ProtoSerialize",1,"Mezzanine::Quaternion const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Quaternion_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Quaternion const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Quaternion::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Quaternion::ProtoDeSerialize",1,"Mezzanine::Quaternion *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Quaternion::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Quaternion_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Quaternion_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Quaternion_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Quaternion::SerializableName",0,0)
  result = Mezzanine::Quaternion::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Quaternion(void *obj) {
Mezzanine::Quaternion *arg1 = (Mezzanine::Quaternion *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Quaternion_methods[] = {
    {"SetIdentity", _wrap_Quaternion_SetIdentity}, 
    {"SetValues", _wrap_Quaternion_SetValues}, 
    {"SetFromAxisAngle", _wrap_Quaternion_SetFromAxisAngle}, 
    {"SetFromMatrix3x3", _wrap_Quaternion_SetFromMatrix3x3}, 
    {"SetFromAxes", _wrap_Quaternion_SetFromAxes}, 
    {"DotProduct", _wrap_Quaternion_DotProduct}, 
    {"Length", _wrap_Quaternion_Length}, 
    {"LengthSqrd", _wrap_Quaternion_LengthSqrd}, 
    {"Normalize", _wrap_Quaternion_Normalize}, 
    {"GetNormalizedCopy", _wrap_Quaternion_GetNormalizedCopy}, 
    {"GetInverse", _wrap_Quaternion_GetInverse}, 
    {"GetBulletQuaternion", _wrap_Quaternion_GetBulletQuaternion}, 
    {"ExtractBulletQuaternion", _wrap_Quaternion_ExtractBulletQuaternion}, 
    {"GetOgreQuaternion", _wrap_Quaternion_GetOgreQuaternion}, 
    {"ExtractOgreQuaternion", _wrap_Quaternion_ExtractOgreQuaternion}, 
    {"__div", _wrap_Quaternion___div}, 
    {"__add", _wrap_Quaternion___add}, 
    {"__sub", _wrap_Quaternion___sub}, 
    {"__mul", _wrap_Quaternion___mul}, 
    {"__eq", _wrap_Quaternion___eq}, 
    {"__le", _wrap_Quaternion___le}, 
    {"ProtoSerialize", _wrap_Quaternion_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Quaternion_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Quaternion_attributes[] = {
    { "X", _wrap_Quaternion_X_get, _wrap_Quaternion_X_set},
    { "Y", _wrap_Quaternion_Y_get, _wrap_Quaternion_Y_set},
    { "Z", _wrap_Quaternion_Z_get, _wrap_Quaternion_Z_set},
    { "W", _wrap_Quaternion_W_get, _wrap_Quaternion_W_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Quaternion_bases[] = {0};
static const char *swig_Mezzanine_Quaternion_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Quaternion = { "Quaternion", &SWIGTYPE_p_Mezzanine__Quaternion,_wrap_new_Quaternion, swig_delete_Quaternion, swig_Mezzanine_Quaternion_methods, swig_Mezzanine_Quaternion_attributes, swig_Mezzanine_Quaternion_bases, swig_Mezzanine_Quaternion_base_names };

static int _wrap_TransformableObject_SetLocation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::SetLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::SetLocation",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::SetLocation",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_SetLocation",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_SetLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLocation((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetLocation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::SetLocation",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::SetLocation",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::SetLocation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableObject::SetLocation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableObject::SetLocation",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_SetLocation",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetLocation(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetLocation(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_SetLocation__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableObject_SetLocation__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_SetLocation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::SetLocation(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableObject::SetLocation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_GetLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::GetLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::GetLocation",1,"Mezzanine::TransformableObject const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_GetLocation",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->GetLocation();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetOrientation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::SetOrientation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_SetOrientation",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableObject_SetOrientation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetOrientation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetOrientation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::SetOrientation",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",4,"Mezzanine::Real const");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::TransformableObject::SetOrientation",5,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_SetOrientation",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real const)lua_tonumber(L, 5);
  (arg1)->SetOrientation(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetOrientation(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_SetOrientation__SWIG_0(L);
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_TransformableObject_SetOrientation__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_SetOrientation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::SetOrientation(Mezzanine::Quaternion const &)\n"
    "    Mezzanine::TransformableObject::SetOrientation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_GetOrientation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::GetOrientation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::GetOrientation",1,"Mezzanine::TransformableObject const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_GetOrientation",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->GetOrientation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetScale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::SetScale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::SetScale",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::SetScale",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_SetScale",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_SetScale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetScale((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetScale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::SetScale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::SetScale",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::SetScale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableObject::SetScale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableObject::SetScale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_SetScale",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetScale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_SetScale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_SetScale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableObject_SetScale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_SetScale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::SetScale(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableObject::SetScale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_GetScale(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::GetScale",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::GetScale",1,"Mezzanine::TransformableObject const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_GetScale",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->GetScale();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Translate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Translate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Translate",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Translate",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Translate",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_Translate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Translate((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Translate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Translate",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Translate",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Translate",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableObject::Translate",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableObject::Translate",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Translate",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Translate(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Translate(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_Translate__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableObject_Translate__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_Translate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::Translate(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableObject::Translate(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_Yaw(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Yaw",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Yaw",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Yaw",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Yaw",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Yaw(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Pitch(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Pitch",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Pitch",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Pitch",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Pitch",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Pitch(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Roll(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Roll",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Roll",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Roll",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Roll",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Roll(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Rotate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Rotate",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Rotate",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Rotate",2,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableObject::Rotate",3,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Rotate",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_Rotate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  (arg1)->Rotate((Mezzanine::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Rotate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Rotate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Rotate",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Rotate",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Rotate",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableObject_Rotate",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->Rotate((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Rotate(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_Rotate__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableObject_Rotate__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_Rotate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::Rotate(Mezzanine::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::TransformableObject::Rotate(Mezzanine::Quaternion const &)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_Scale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Scale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Scale",1,"Mezzanine::TransformableObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Scale",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Scale",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_Scale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Scale((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Scale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::Scale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::Scale",1,"Mezzanine::TransformableObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::Scale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableObject::Scale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableObject::Scale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_Scale",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Scale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_Scale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_Scale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableObject_Scale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_Scale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::Scale(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableObject::Scale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_ConvertLocalToGlobal__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::ConvertLocalToGlobal",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertLocalToGlobal",1,"Mezzanine::TransformableObject const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertLocalToGlobal",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_ConvertLocalToGlobal",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_ConvertLocalToGlobal",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->ConvertLocalToGlobal((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_ConvertGlobalToLocal__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::ConvertGlobalToLocal",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertGlobalToLocal",1,"Mezzanine::TransformableObject const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertGlobalToLocal",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_ConvertGlobalToLocal",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableObject_ConvertGlobalToLocal",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->ConvertGlobalToLocal((Mezzanine::Vector3 const &)*arg2);
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_ConvertLocalToGlobal__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::ConvertLocalToGlobal",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertLocalToGlobal",1,"Mezzanine::TransformableObject const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertLocalToGlobal",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_ConvertLocalToGlobal",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableObject_ConvertLocalToGlobal",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->ConvertLocalToGlobal((Mezzanine::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_ConvertLocalToGlobal(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_ConvertLocalToGlobal__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_ConvertLocalToGlobal__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_ConvertLocalToGlobal'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::ConvertLocalToGlobal(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::TransformableObject::ConvertLocalToGlobal(Mezzanine::Quaternion const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableObject_ConvertGlobalToLocal__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::TransformableObject::ConvertGlobalToLocal",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertGlobalToLocal",1,"Mezzanine::TransformableObject const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableObject::ConvertGlobalToLocal",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("TransformableObject_ConvertGlobalToLocal",1,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableObject_ConvertGlobalToLocal",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = ((Mezzanine::TransformableObject const *)arg1)->ConvertGlobalToLocal((Mezzanine::Quaternion const &)*arg2);
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableObject_ConvertGlobalToLocal(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_ConvertGlobalToLocal__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableObject_ConvertGlobalToLocal__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableObject_ConvertGlobalToLocal'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableObject::ConvertGlobalToLocal(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::TransformableObject::ConvertGlobalToLocal(Mezzanine::Quaternion const &) const\n");
  lua_error(L);return 0;
}


static void swig_delete_TransformableObject(void *obj) {
Mezzanine::TransformableObject *arg1 = (Mezzanine::TransformableObject *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_TransformableObject_methods[] = {
    {"SetLocation", _wrap_TransformableObject_SetLocation}, 
    {"GetLocation", _wrap_TransformableObject_GetLocation}, 
    {"SetOrientation", _wrap_TransformableObject_SetOrientation}, 
    {"GetOrientation", _wrap_TransformableObject_GetOrientation}, 
    {"SetScale", _wrap_TransformableObject_SetScale}, 
    {"GetScale", _wrap_TransformableObject_GetScale}, 
    {"Translate", _wrap_TransformableObject_Translate}, 
    {"Yaw", _wrap_TransformableObject_Yaw}, 
    {"Pitch", _wrap_TransformableObject_Pitch}, 
    {"Roll", _wrap_TransformableObject_Roll}, 
    {"Rotate", _wrap_TransformableObject_Rotate}, 
    {"Scale", _wrap_TransformableObject_Scale}, 
    {"ConvertLocalToGlobal", _wrap_TransformableObject_ConvertLocalToGlobal}, 
    {"ConvertGlobalToLocal", _wrap_TransformableObject_ConvertGlobalToLocal}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_TransformableObject_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_TransformableObject_bases[] = {0};
static const char *swig_Mezzanine_TransformableObject_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_TransformableObject = { "TransformableObject", &SWIGTYPE_p_Mezzanine__TransformableObject,0, swig_delete_TransformableObject, swig_Mezzanine_TransformableObject_methods, swig_Mezzanine_TransformableObject_attributes, swig_Mezzanine_TransformableObject_bases, swig_Mezzanine_TransformableObject_base_names };

static int _wrap_TransformableChildObject_SetLocation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::SetLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetLocation",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetLocation",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_SetLocation",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_SetLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLocation((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetLocation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::SetLocation",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetLocation",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetLocation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetLocation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetLocation",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_SetLocation",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetLocation(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetLocation(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableChildObject_SetLocation__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableChildObject_SetLocation__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_SetLocation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::SetLocation(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableChildObject::SetLocation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_GetLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::GetLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::GetLocation",1,"Mezzanine::TransformableChildObject const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_GetLocation",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  result = ((Mezzanine::TransformableChildObject const *)arg1)->GetLocation();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetOrientation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::SetOrientation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_SetOrientation",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableChildObject_SetOrientation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetOrientation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetOrientation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::SetOrientation",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",4,"Mezzanine::Real const");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetOrientation",5,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_SetOrientation",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real const)lua_tonumber(L, 5);
  (arg1)->SetOrientation(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetOrientation(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableChildObject_SetOrientation__SWIG_0(L);
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_TransformableChildObject_SetOrientation__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_SetOrientation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::SetOrientation(Mezzanine::Quaternion const &)\n"
    "    Mezzanine::TransformableChildObject::SetOrientation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_GetOrientation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::GetOrientation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::GetOrientation",1,"Mezzanine::TransformableChildObject const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_GetOrientation",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  result = ((Mezzanine::TransformableChildObject const *)arg1)->GetOrientation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetScale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::SetScale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetScale",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetScale",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_SetScale",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_SetScale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetScale((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetScale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::SetScale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetScale",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetScale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetScale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::SetScale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_SetScale",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetScale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_SetScale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableChildObject_SetScale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableChildObject_SetScale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_SetScale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::SetScale(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableChildObject::SetScale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_GetScale(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::GetScale",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::GetScale",1,"Mezzanine::TransformableChildObject const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_GetScale",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  result = ((Mezzanine::TransformableChildObject const *)arg1)->GetScale();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Translate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::TransformSpace arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Translate",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",2,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",3,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Translate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_Translate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 3);
  (arg1)->Translate((Mezzanine::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Translate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Translate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Translate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_Translate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Translate((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Translate__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::TransformSpace arg5 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Translate",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",4,"Mezzanine::Real const");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",5,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Translate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  arg5 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 5);
  (arg1)->Translate(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Translate__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Translate",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Translate",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Translate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Translate(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Translate(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableChildObject_Translate__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableChildObject_Translate__SWIG_0(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableChildObject_Translate__SWIG_3(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_TransformableChildObject_Translate__SWIG_2(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_Translate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::Translate(Mezzanine::Vector3 const &,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Translate(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableChildObject::Translate(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Translate(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_Yaw__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::TransformSpace arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Yaw",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Yaw",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Yaw",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Yaw",3,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Yaw",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 3);
  (arg1)->Yaw(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Yaw__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Yaw",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Yaw",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Yaw",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Yaw",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Yaw(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Yaw(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_TransformableChildObject_Yaw__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableChildObject_Yaw__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_Yaw'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::Yaw(Mezzanine::Real const,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Yaw(Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_Pitch__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::TransformSpace arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Pitch",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Pitch",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Pitch",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Pitch",3,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Pitch",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 3);
  (arg1)->Pitch(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Pitch__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Pitch",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Pitch",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Pitch",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Pitch",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Pitch(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Pitch(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_TransformableChildObject_Pitch__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableChildObject_Pitch__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_Pitch'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::Pitch(Mezzanine::Real const,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Pitch(Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_Roll__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::TransformSpace arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Roll",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Roll",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Roll",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Roll",3,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Roll",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 3);
  (arg1)->Roll(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Roll__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Roll",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Roll",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Roll",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Roll",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Roll(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Roll(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_TransformableChildObject_Roll__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableChildObject_Roll__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_Roll'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::Roll(Mezzanine::Real const,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Roll(Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_Rotate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  Mezzanine::TransformSpace arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Rotate",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",2,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",4,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 4);
  (arg1)->Rotate((Mezzanine::Vector3 const &)*arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Rotate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Rotate",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",2,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",3,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  (arg1)->Rotate((Mezzanine::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Rotate__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::TransformSpace arg3 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Rotate",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",2,"Mezzanine::Quaternion const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",3,"Mezzanine::TransformSpace const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg3 = (Mezzanine::TransformSpace const)(int)lua_tonumber(L, 3);
  (arg1)->Rotate((Mezzanine::Quaternion const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Rotate__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Rotate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Rotate",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("TransformableChildObject_Rotate",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->Rotate((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Rotate(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableChildObject_Rotate__SWIG_3(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableChildObject_Rotate__SWIG_2(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_TransformableChildObject_Rotate__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableChildObject_Rotate__SWIG_0(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_Rotate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::Rotate(Mezzanine::Vector3 const &,Mezzanine::Real const,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Rotate(Mezzanine::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::TransformableChildObject::Rotate(Mezzanine::Quaternion const &,Mezzanine::TransformSpace const)\n"
    "    Mezzanine::TransformableChildObject::Rotate(Mezzanine::Quaternion const &)\n");
  lua_error(L);return 0;
}


static int _wrap_TransformableChildObject_Scale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Scale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Scale",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Scale",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Scale",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("TransformableChildObject_Scale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Scale((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Scale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::TransformableChildObject::Scale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Scale",1,"Mezzanine::TransformableChildObject *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Scale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Scale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::TransformableChildObject::Scale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__TransformableChildObject,0))){
    SWIG_fail_ptr("TransformableChildObject_Scale",1,SWIGTYPE_p_Mezzanine__TransformableChildObject);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Scale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_TransformableChildObject_Scale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_TransformableChildObject_Scale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__TransformableChildObject, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_TransformableChildObject_Scale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'TransformableChildObject_Scale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::TransformableChildObject::Scale(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::TransformableChildObject::Scale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static void swig_delete_TransformableChildObject(void *obj) {
Mezzanine::TransformableChildObject *arg1 = (Mezzanine::TransformableChildObject *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_TransformableChildObject_methods[] = {
    {"SetLocation", _wrap_TransformableChildObject_SetLocation}, 
    {"GetLocation", _wrap_TransformableChildObject_GetLocation}, 
    {"SetOrientation", _wrap_TransformableChildObject_SetOrientation}, 
    {"GetOrientation", _wrap_TransformableChildObject_GetOrientation}, 
    {"SetScale", _wrap_TransformableChildObject_SetScale}, 
    {"GetScale", _wrap_TransformableChildObject_GetScale}, 
    {"Translate", _wrap_TransformableChildObject_Translate}, 
    {"Yaw", _wrap_TransformableChildObject_Yaw}, 
    {"Pitch", _wrap_TransformableChildObject_Pitch}, 
    {"Roll", _wrap_TransformableChildObject_Roll}, 
    {"Rotate", _wrap_TransformableChildObject_Rotate}, 
    {"Scale", _wrap_TransformableChildObject_Scale}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_TransformableChildObject_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_TransformableChildObject_bases[] = {0};
static const char *swig_Mezzanine_TransformableChildObject_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_TransformableChildObject = { "TransformableChildObject", &SWIGTYPE_p_Mezzanine__TransformableChildObject,0, swig_delete_TransformableChildObject, swig_Mezzanine_TransformableChildObject_methods, swig_Mezzanine_TransformableChildObject_attributes, swig_Mezzanine_TransformableChildObject_bases, swig_Mezzanine_TransformableChildObject_base_names };

static int _wrap_WorldProxy_GetProxyType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::ProxyType result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetProxyType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetProxyType",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetProxyType",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = (Mezzanine::ProxyType)((Mezzanine::WorldProxy const *)arg1)->GetProxyType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_AddToWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::AddToWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::AddToWorld",1,"Mezzanine::WorldProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_AddToWorld",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  (arg1)->AddToWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_RemoveFromWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::RemoveFromWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::RemoveFromWorld",1,"Mezzanine::WorldProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_RemoveFromWorld",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  (arg1)->RemoveFromWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_IsInWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::IsInWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::IsInWorld",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_IsInWorld",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::WorldProxy const *)arg1)->IsInWorld();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_GetParentObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::WorldObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetParentObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetParentObject",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetParentObject",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = (Mezzanine::WorldObject *)((Mezzanine::WorldProxy const *)arg1)->GetParentObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_GetCreator(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::WorldManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetCreator",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetCreator",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetCreator",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = (Mezzanine::WorldManager *)((Mezzanine::WorldProxy const *)arg1)->GetCreator();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldManager,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetLocation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::SetLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::SetLocation",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::SetLocation",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_SetLocation",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("WorldProxy_SetLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLocation((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetLocation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::SetLocation",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::SetLocation",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::SetLocation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::WorldProxy::SetLocation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::WorldProxy::SetLocation",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_SetLocation",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetLocation(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetLocation(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_WorldProxy_SetLocation__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_WorldProxy_SetLocation__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'WorldProxy_SetLocation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::WorldProxy::SetLocation(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::WorldProxy::SetLocation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldProxy_GetLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetLocation",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetLocation",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = ((Mezzanine::WorldProxy const *)arg1)->GetLocation();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetOrientation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::SetOrientation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_SetOrientation",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("WorldProxy_SetOrientation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetOrientation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetOrientation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::SetOrientation",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",4,"Mezzanine::Real const");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::WorldProxy::SetOrientation",5,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_SetOrientation",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real const)lua_tonumber(L, 5);
  (arg1)->SetOrientation(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetOrientation(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_WorldProxy_SetOrientation__SWIG_0(L);
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_WorldProxy_SetOrientation__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'WorldProxy_SetOrientation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::WorldProxy::SetOrientation(Mezzanine::Quaternion const &)\n"
    "    Mezzanine::WorldProxy::SetOrientation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldProxy_GetOrientation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetOrientation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetOrientation",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetOrientation",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = ((Mezzanine::WorldProxy const *)arg1)->GetOrientation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetScale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::SetScale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::SetScale",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::SetScale",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_SetScale",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("WorldProxy_SetScale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetScale((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetScale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::SetScale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::SetScale",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::SetScale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::WorldProxy::SetScale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::WorldProxy::SetScale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_SetScale",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetScale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_SetScale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_WorldProxy_SetScale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_WorldProxy_SetScale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'WorldProxy_SetScale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::WorldProxy::SetScale(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::WorldProxy::SetScale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldProxy_GetScale(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetScale",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetScale",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetScale",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = ((Mezzanine::WorldProxy const *)arg1)->GetScale();
  {
    Mezzanine::Vector3 * resultptr = new Mezzanine::Vector3((const Mezzanine::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Translate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Translate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Translate",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Translate",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Translate",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("WorldProxy_Translate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Translate((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Translate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Translate",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Translate",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Translate",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::WorldProxy::Translate",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::WorldProxy::Translate",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Translate",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Translate(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Translate(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_WorldProxy_Translate__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_WorldProxy_Translate__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'WorldProxy_Translate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::WorldProxy::Translate(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::WorldProxy::Translate(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldProxy_Yaw(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Yaw",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Yaw",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Yaw",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Yaw",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Yaw(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Pitch(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Pitch",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Pitch",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Pitch",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Pitch",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Pitch(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Roll(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Roll",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Roll",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Roll",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Roll",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Roll(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Rotate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Rotate",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Rotate",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Rotate",2,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::WorldProxy::Rotate",3,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Rotate",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("WorldProxy_Rotate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  (arg1)->Rotate((Mezzanine::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Rotate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Rotate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Rotate",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Rotate",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Rotate",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("WorldProxy_Rotate",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->Rotate((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Rotate(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_WorldProxy_Rotate__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_WorldProxy_Rotate__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'WorldProxy_Rotate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::WorldProxy::Rotate(Mezzanine::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::WorldProxy::Rotate(Mezzanine::Quaternion const &)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldProxy_Scale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Scale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Scale",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Scale",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Scale",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("WorldProxy_Scale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Scale((Mezzanine::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Scale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::Scale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::Scale",1,"Mezzanine::WorldProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::Scale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::WorldProxy::Scale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::WorldProxy::Scale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_Scale",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Scale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_Scale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_WorldProxy_Scale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_WorldProxy_Scale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'WorldProxy_Scale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::WorldProxy::Scale(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::WorldProxy::Scale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_WorldProxy_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoSerialize",1,"Mezzanine::WorldProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("WorldProxy_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::WorldProxy const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_ProtoSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::ProtoSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoSerializeProperties",1,"Mezzanine::WorldProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoSerializeProperties",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_ProtoSerializeProperties",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("WorldProxy_ProtoSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::WorldProxy const *)arg1)->ProtoSerializeProperties(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoDeSerialize",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("WorldProxy_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_ProtoDeSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::ProtoDeSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoDeSerializeProperties",1,"Mezzanine::WorldProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::ProtoDeSerializeProperties",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_ProtoDeSerializeProperties",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("WorldProxy_ProtoDeSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerializeProperties((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_GetDerivedSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetDerivedSerializableName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::GetDerivedSerializableName",1,"Mezzanine::WorldProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy_GetDerivedSerializableName",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  result = ((Mezzanine::WorldProxy const *)arg1)->GetDerivedSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy_GetSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::GetSerializableName",0,0)
  result = Mezzanine::WorldProxy::GetSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_WorldProxy__Bind(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) 0 ;
  Mezzanine::WorldObject *arg2 = (Mezzanine::WorldObject *) 0 ;
  
  SWIG_check_num_args("Mezzanine::WorldProxy::_Bind",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::WorldProxy::_Bind",1,"Mezzanine::WorldProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::WorldProxy::_Bind",2,"Mezzanine::WorldObject *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__WorldProxy,0))){
    SWIG_fail_ptr("WorldProxy__Bind",1,SWIGTYPE_p_Mezzanine__WorldProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__WorldObject,0))){
    SWIG_fail_ptr("WorldProxy__Bind",2,SWIGTYPE_p_Mezzanine__WorldObject);
  }
  
  (arg1)->_Bind(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_WorldProxy(void *obj) {
Mezzanine::WorldProxy *arg1 = (Mezzanine::WorldProxy *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_WorldProxy_methods[] = {
    {"GetProxyType", _wrap_WorldProxy_GetProxyType}, 
    {"AddToWorld", _wrap_WorldProxy_AddToWorld}, 
    {"RemoveFromWorld", _wrap_WorldProxy_RemoveFromWorld}, 
    {"IsInWorld", _wrap_WorldProxy_IsInWorld}, 
    {"GetParentObject", _wrap_WorldProxy_GetParentObject}, 
    {"GetCreator", _wrap_WorldProxy_GetCreator}, 
    {"SetLocation", _wrap_WorldProxy_SetLocation}, 
    {"GetLocation", _wrap_WorldProxy_GetLocation}, 
    {"SetOrientation", _wrap_WorldProxy_SetOrientation}, 
    {"GetOrientation", _wrap_WorldProxy_GetOrientation}, 
    {"SetScale", _wrap_WorldProxy_SetScale}, 
    {"GetScale", _wrap_WorldProxy_GetScale}, 
    {"Translate", _wrap_WorldProxy_Translate}, 
    {"Yaw", _wrap_WorldProxy_Yaw}, 
    {"Pitch", _wrap_WorldProxy_Pitch}, 
    {"Roll", _wrap_WorldProxy_Roll}, 
    {"Rotate", _wrap_WorldProxy_Rotate}, 
    {"Scale", _wrap_WorldProxy_Scale}, 
    {"ProtoSerialize", _wrap_WorldProxy_ProtoSerialize}, 
    {"ProtoSerializeProperties", _wrap_WorldProxy_ProtoSerializeProperties}, 
    {"ProtoDeSerialize", _wrap_WorldProxy_ProtoDeSerialize}, 
    {"ProtoDeSerializeProperties", _wrap_WorldProxy_ProtoDeSerializeProperties}, 
    {"GetDerivedSerializableName", _wrap_WorldProxy_GetDerivedSerializableName}, 
    {"_Bind", _wrap_WorldProxy__Bind}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_WorldProxy_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_WorldProxy_bases[] = {0,0};
static const char *swig_Mezzanine_WorldProxy_base_names[] = {"Mezzanine::TransformableObject *",0};
static swig_lua_class _wrap_class_Mezzanine_WorldProxy = { "WorldProxy", &SWIGTYPE_p_Mezzanine__WorldProxy,0, swig_delete_WorldProxy, swig_Mezzanine_WorldProxy_methods, swig_Mezzanine_WorldProxy_attributes, swig_Mezzanine_WorldProxy_bases, swig_Mezzanine_WorldProxy_base_names };

static int _wrap_CollidableProxy_GetAABB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  AxisAlignedBox result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetAABB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetAABB",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetAABB",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = ((Mezzanine::Physics::CollidableProxy const *)arg1)->GetAABB();
  {
    AxisAlignedBox * resultptr = new AxisAlignedBox((const AxisAlignedBox &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_AxisAlignedBox,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_AddToWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::AddToWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::AddToWorld",1,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_AddToWorld",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->AddToWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_RemoveFromWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::RemoveFromWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::RemoveFromWorld",1,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_RemoveFromWorld",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->RemoveFromWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_IsInWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::IsInWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsInWorld",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_IsInWorld",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->IsInWorld();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetCreator(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::WorldManager *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetCreator",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetCreator",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetCreator",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::WorldManager *)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetCreator();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldManager,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetCollisionGroupAndMask(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Int16 arg2 ;
  Mezzanine::Int16 arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetCollisionGroupAndMask",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionGroupAndMask",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionGroupAndMask",2,"Mezzanine::Int16 const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionGroupAndMask",3,"Mezzanine::Int16 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionGroupAndMask",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Int16 const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Int16 const)lua_tonumber(L, 3);
  (arg1)->SetCollisionGroupAndMask(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetCollisionGroup(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Int16 arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetCollisionGroup",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionGroup",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionGroup",2,"Mezzanine::Int16 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionGroup",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Int16 const)lua_tonumber(L, 2);
  (arg1)->SetCollisionGroup(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetCollisionMask(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Int16 arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetCollisionMask",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionMask",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionMask",2,"Mezzanine::Int16 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionMask",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Int16 const)lua_tonumber(L, 2);
  (arg1)->SetCollisionMask(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetCollisionGroup(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Int16 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetCollisionGroup",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetCollisionGroup",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetCollisionGroup",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Int16)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetCollisionGroup();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetCollisionMask(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Int16 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetCollisionMask",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetCollisionMask",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetCollisionMask",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Int16)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetCollisionMask();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetCollisionShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionShape",1,"Mezzanine::Physics::CollidableProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionShape",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->SetCollisionShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetCollisionShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetCollisionShape",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetCollisionShape",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Physics::CollisionShape *)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetCollisionShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetCollisionResponse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetCollisionResponse",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionResponse",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionResponse",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionResponse",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetCollisionResponse(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetCollisionResponse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetCollisionResponse",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetCollisionResponse",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetCollisionResponse",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetCollisionResponse();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetCollisionFlags(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Whole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetCollisionFlags",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionFlags",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetCollisionFlags",2,"Mezzanine::Whole const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetCollisionFlags",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::Whole const)lua_tonumber(L, 2);
  (arg1)->SetCollisionFlags(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetCollisionFlags(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetCollisionFlags",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetCollisionFlags",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetCollisionFlags",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetCollisionFlags();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetKinematic(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetKinematic",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetKinematic",1,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetKinematic",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->SetKinematic();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetStatic(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetStatic",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetStatic",1,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetStatic",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->SetStatic();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_IsKinematic(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::IsKinematic",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsKinematic",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_IsKinematic",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->IsKinematic();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_IsStatic(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::IsStatic",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsStatic",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_IsStatic",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->IsStatic();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_IsStaticOrKinematic(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::IsStaticOrKinematic",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsStaticOrKinematic",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_IsStaticOrKinematic",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->IsStaticOrKinematic();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetFriction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetFriction",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetFriction",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetFriction",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetFriction",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->SetFriction(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetFriction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetFriction",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetFriction",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetFriction",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetFriction();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetRollingFriction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetRollingFriction",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetRollingFriction",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetRollingFriction",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetRollingFriction",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->SetRollingFriction(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetRollingFriction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetRollingFriction",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetRollingFriction",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetRollingFriction",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetRollingFriction();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetAnisotropicFriction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Whole arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetAnisotropicFriction",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetAnisotropicFriction",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetAnisotropicFriction",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetAnisotropicFriction",3,"Mezzanine::Whole const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetAnisotropicFriction",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollidableProxy_SetAnisotropicFriction",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
  arg3 = (Mezzanine::Whole const)lua_tonumber(L, 3);
  (arg1)->SetAnisotropicFriction((Mezzanine::Physics::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetAnisotropicFrictionMode(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::AnisotropicFrictionFlags result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetAnisotropicFrictionMode",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetAnisotropicFrictionMode",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetAnisotropicFrictionMode",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Physics::AnisotropicFrictionFlags)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetAnisotropicFrictionMode();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_IsAnisotropicFrictionModeSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Whole arg2 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::IsAnisotropicFrictionModeSet",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsAnisotropicFrictionModeSet",1,"Mezzanine::Physics::CollidableProxy const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsAnisotropicFrictionModeSet",2,"Mezzanine::Whole const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_IsAnisotropicFrictionModeSet",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::Whole const)lua_tonumber(L, 2);
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->IsAnisotropicFrictionModeSet(arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetAnisotropicFriction(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetAnisotropicFriction",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetAnisotropicFriction",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetAnisotropicFriction",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = ((Mezzanine::Physics::CollidableProxy const *)arg1)->GetAnisotropicFriction();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetRestitution(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetRestitution",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetRestitution",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetRestitution",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetRestitution",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitution((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetRestitution(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetRestitution",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetRestitution",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetRestitution",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetRestitution();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetActivationState__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::ActivationState arg2 ;
  Mezzanine::Boole arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetActivationState",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetActivationState",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetActivationState",2,"Mezzanine::Physics::ActivationState const");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetActivationState",3,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetActivationState",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Physics::ActivationState const)(int)lua_tonumber(L, 2);
  arg3 = (lua_toboolean(L, 3)!=0);
  (arg1)->SetActivationState(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetActivationState__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::ActivationState arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetActivationState",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetActivationState",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetActivationState",2,"Mezzanine::Physics::ActivationState const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetActivationState",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Physics::ActivationState const)(int)lua_tonumber(L, 2);
  (arg1)->SetActivationState(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetActivationState(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_CollidableProxy_SetActivationState__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isboolean(L,argv[2]);
        }
        if (_v) {
          return _wrap_CollidableProxy_SetActivationState__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_SetActivationState'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::SetActivationState(Mezzanine::Physics::ActivationState const,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::CollidableProxy::SetActivationState(Mezzanine::Physics::ActivationState const)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_GetActivationState(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::ActivationState result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetActivationState",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetActivationState",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetActivationState",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Physics::ActivationState)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetActivationState();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_IsActive(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::IsActive",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::IsActive",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_IsActive",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::CollidableProxy const *)arg1)->IsActive();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetDeactivationTime(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetDeactivationTime",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetDeactivationTime",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetDeactivationTime",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetDeactivationTime",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->SetDeactivationTime(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetDeactivationTime(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetDeactivationTime",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetDeactivationTime",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetDeactivationTime",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CollidableProxy const *)arg1)->GetDeactivationTime();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetLocation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetLocation",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetLocation",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollidableProxy_SetLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetLocation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetLocation",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetLocation",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetLocation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetLocation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetLocation",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetLocation",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetLocation(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetLocation(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollidableProxy_SetLocation__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollidableProxy_SetLocation__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_SetLocation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::SetLocation(Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CollidableProxy::SetLocation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_GetLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetLocation",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetLocation",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = ((Mezzanine::Physics::CollidableProxy const *)arg1)->GetLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetOrientation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetOrientation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetOrientation",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("CollidableProxy_SetOrientation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetOrientation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetOrientation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetOrientation",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",4,"Mezzanine::Real const");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetOrientation",5,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetOrientation",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real const)lua_tonumber(L, 5);
  (arg1)->SetOrientation(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetOrientation(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollidableProxy_SetOrientation__SWIG_0(L);
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_CollidableProxy_SetOrientation__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_SetOrientation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::SetOrientation(Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::CollidableProxy::SetOrientation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_GetOrientation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetOrientation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetOrientation",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetOrientation",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = ((Mezzanine::Physics::CollidableProxy const *)arg1)->GetOrientation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetScale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetScale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetScale",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetScale",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetScale",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollidableProxy_SetScale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetScale((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetScale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::SetScale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetScale",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetScale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetScale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::SetScale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_SetScale",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetScale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_SetScale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollidableProxy_SetScale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollidableProxy_SetScale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_SetScale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::SetScale(Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CollidableProxy::SetScale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_GetScale(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetScale",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetScale",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetScale",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = ((Mezzanine::Physics::CollidableProxy const *)arg1)->GetScale();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Translate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Translate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Translate",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Translate",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Translate",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollidableProxy_Translate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Translate((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Translate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Translate",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Translate",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Translate",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Translate",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Translate",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Translate",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Translate(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Translate(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollidableProxy_Translate__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollidableProxy_Translate__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_Translate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::Translate(Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CollidableProxy::Translate(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_Yaw(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Yaw",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Yaw",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Yaw",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Yaw",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Yaw(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Pitch(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Pitch",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Pitch",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Pitch",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Pitch",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Pitch(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Roll(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Roll",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Roll",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Roll",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Roll",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->Roll(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Rotate__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Rotate",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Rotate",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Rotate",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Rotate",3,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Rotate",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollidableProxy_Rotate",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  (arg1)->Rotate((Mezzanine::Physics::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Rotate__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Rotate",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Rotate",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Rotate",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Rotate",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("CollidableProxy_Rotate",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->Rotate((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Rotate(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollidableProxy_Rotate__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_CollidableProxy_Rotate__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_Rotate'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::Rotate(Mezzanine::Physics::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::Physics::CollidableProxy::Rotate(Mezzanine::Quaternion const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_Scale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Scale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Scale",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Scale",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Scale",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CollidableProxy_Scale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Scale((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Scale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::Scale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Scale",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Scale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Scale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::Scale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_Scale",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->Scale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_Scale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CollidableProxy_Scale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_CollidableProxy_Scale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CollidableProxy_Scale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CollidableProxy::Scale(Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CollidableProxy::Scale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_CollidableProxy_ProtoSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::ProtoSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoSerializeProperties",1,"Mezzanine::Physics::CollidableProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoSerializeProperties",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::CollidableProxy const *)arg1)->ProtoSerializeProperties(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_ProtoSerializeShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::ProtoSerializeShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoSerializeShape",1,"Mezzanine::Physics::CollidableProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoSerializeShape",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoSerializeShape",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoSerializeShape",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::CollidableProxy const *)arg1)->ProtoSerializeShape(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_ProtoDeSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::ProtoDeSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoDeSerializeProperties",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoDeSerializeProperties",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoDeSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoDeSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerializeProperties((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_ProtoDeSerializeShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::ProtoDeSerializeShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoDeSerializeShape",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::ProtoDeSerializeShape",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoDeSerializeShape",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CollidableProxy_ProtoDeSerializeShape",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerializeShape((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetDerivedSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetDerivedSerializableName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::GetDerivedSerializableName",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy_GetDerivedSerializableName",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = ((Mezzanine::Physics::CollidableProxy const *)arg1)->GetDerivedSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy_GetSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::GetSerializableName",0,0)
  result = Mezzanine::Physics::CollidableProxy::GetSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy__GetBroadphaseUniqueID(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Integer result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::_GetBroadphaseUniqueID",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::_GetBroadphaseUniqueID",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy__GetBroadphaseUniqueID",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Integer)((Mezzanine::Physics::CollidableProxy const *)arg1)->_GetBroadphaseUniqueID();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy__SetContactProcessingThreshold(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::_SetContactProcessingThreshold",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::_SetContactProcessingThreshold",1,"Mezzanine::Physics::CollidableProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::_SetContactProcessingThreshold",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy__SetContactProcessingThreshold",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->_SetContactProcessingThreshold(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy__GetContactProcessingThreshold(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::_GetContactProcessingThreshold",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::_GetContactProcessingThreshold",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy__GetContactProcessingThreshold",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CollidableProxy const *)arg1)->_GetContactProcessingThreshold();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CollidableProxy__GetBasePhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  btCollisionObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CollidableProxy::_GetBasePhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CollidableProxy::_GetBasePhysicsObject",1,"Mezzanine::Physics::CollidableProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("CollidableProxy__GetBasePhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (btCollisionObject *)((Mezzanine::Physics::CollidableProxy const *)arg1)->_GetBasePhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCollisionObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CollidableProxy(void *obj) {
Mezzanine::Physics::CollidableProxy *arg1 = (Mezzanine::Physics::CollidableProxy *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CollidableProxy_methods[] = {
    {"GetAABB", _wrap_CollidableProxy_GetAABB}, 
    {"AddToWorld", _wrap_CollidableProxy_AddToWorld}, 
    {"RemoveFromWorld", _wrap_CollidableProxy_RemoveFromWorld}, 
    {"IsInWorld", _wrap_CollidableProxy_IsInWorld}, 
    {"GetCreator", _wrap_CollidableProxy_GetCreator}, 
    {"SetCollisionGroupAndMask", _wrap_CollidableProxy_SetCollisionGroupAndMask}, 
    {"SetCollisionGroup", _wrap_CollidableProxy_SetCollisionGroup}, 
    {"SetCollisionMask", _wrap_CollidableProxy_SetCollisionMask}, 
    {"GetCollisionGroup", _wrap_CollidableProxy_GetCollisionGroup}, 
    {"GetCollisionMask", _wrap_CollidableProxy_GetCollisionMask}, 
    {"SetCollisionShape", _wrap_CollidableProxy_SetCollisionShape}, 
    {"GetCollisionShape", _wrap_CollidableProxy_GetCollisionShape}, 
    {"SetCollisionResponse", _wrap_CollidableProxy_SetCollisionResponse}, 
    {"GetCollisionResponse", _wrap_CollidableProxy_GetCollisionResponse}, 
    {"SetCollisionFlags", _wrap_CollidableProxy_SetCollisionFlags}, 
    {"GetCollisionFlags", _wrap_CollidableProxy_GetCollisionFlags}, 
    {"SetKinematic", _wrap_CollidableProxy_SetKinematic}, 
    {"SetStatic", _wrap_CollidableProxy_SetStatic}, 
    {"IsKinematic", _wrap_CollidableProxy_IsKinematic}, 
    {"IsStatic", _wrap_CollidableProxy_IsStatic}, 
    {"IsStaticOrKinematic", _wrap_CollidableProxy_IsStaticOrKinematic}, 
    {"SetFriction", _wrap_CollidableProxy_SetFriction}, 
    {"GetFriction", _wrap_CollidableProxy_GetFriction}, 
    {"SetRollingFriction", _wrap_CollidableProxy_SetRollingFriction}, 
    {"GetRollingFriction", _wrap_CollidableProxy_GetRollingFriction}, 
    {"SetAnisotropicFriction", _wrap_CollidableProxy_SetAnisotropicFriction}, 
    {"GetAnisotropicFrictionMode", _wrap_CollidableProxy_GetAnisotropicFrictionMode}, 
    {"IsAnisotropicFrictionModeSet", _wrap_CollidableProxy_IsAnisotropicFrictionModeSet}, 
    {"GetAnisotropicFriction", _wrap_CollidableProxy_GetAnisotropicFriction}, 
    {"SetRestitution", _wrap_CollidableProxy_SetRestitution}, 
    {"GetRestitution", _wrap_CollidableProxy_GetRestitution}, 
    {"SetActivationState", _wrap_CollidableProxy_SetActivationState}, 
    {"GetActivationState", _wrap_CollidableProxy_GetActivationState}, 
    {"IsActive", _wrap_CollidableProxy_IsActive}, 
    {"SetDeactivationTime", _wrap_CollidableProxy_SetDeactivationTime}, 
    {"GetDeactivationTime", _wrap_CollidableProxy_GetDeactivationTime}, 
    {"SetLocation", _wrap_CollidableProxy_SetLocation}, 
    {"GetLocation", _wrap_CollidableProxy_GetLocation}, 
    {"SetOrientation", _wrap_CollidableProxy_SetOrientation}, 
    {"GetOrientation", _wrap_CollidableProxy_GetOrientation}, 
    {"SetScale", _wrap_CollidableProxy_SetScale}, 
    {"GetScale", _wrap_CollidableProxy_GetScale}, 
    {"Translate", _wrap_CollidableProxy_Translate}, 
    {"Yaw", _wrap_CollidableProxy_Yaw}, 
    {"Pitch", _wrap_CollidableProxy_Pitch}, 
    {"Roll", _wrap_CollidableProxy_Roll}, 
    {"Rotate", _wrap_CollidableProxy_Rotate}, 
    {"Scale", _wrap_CollidableProxy_Scale}, 
    {"ProtoSerializeProperties", _wrap_CollidableProxy_ProtoSerializeProperties}, 
    {"ProtoSerializeShape", _wrap_CollidableProxy_ProtoSerializeShape}, 
    {"ProtoDeSerializeProperties", _wrap_CollidableProxy_ProtoDeSerializeProperties}, 
    {"ProtoDeSerializeShape", _wrap_CollidableProxy_ProtoDeSerializeShape}, 
    {"GetDerivedSerializableName", _wrap_CollidableProxy_GetDerivedSerializableName}, 
    {"_GetBroadphaseUniqueID", _wrap_CollidableProxy__GetBroadphaseUniqueID}, 
    {"_SetContactProcessingThreshold", _wrap_CollidableProxy__SetContactProcessingThreshold}, 
    {"_GetContactProcessingThreshold", _wrap_CollidableProxy__GetContactProcessingThreshold}, 
    {"_GetBasePhysicsObject", _wrap_CollidableProxy__GetBasePhysicsObject}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CollidableProxy_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CollidableProxy_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_CollidableProxy_base_names[] = {"Mezzanine::WorldProxy *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CollidableProxy = { "CollidableProxy", &SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0, swig_delete_CollidableProxy, swig_Mezzanine_Physics_CollidableProxy_methods, swig_Mezzanine_Physics_CollidableProxy_attributes, swig_Mezzanine_Physics_CollidableProxy_bases, swig_Mezzanine_Physics_CollidableProxy_base_names };

static int _wrap_new_Collision__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::Collision",0,0)
  result = (Mezzanine::Physics::Collision *)new Mezzanine::Physics::Collision();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Collision,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Collision__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = 0 ;
  Mezzanine::Physics::Collision *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::Collision",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::Collision",1,"Mezzanine::Physics::Collision const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("new_Collision",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  result = (Mezzanine::Physics::Collision *)new Mezzanine::Physics::Collision((Mezzanine::Physics::Collision const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Collision,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Collision(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_Collision__SWIG_1(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Collision, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Collision__SWIG_2(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Collision'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Collision::Collision()\n"
    "    Mezzanine::Physics::Collision::Collision(Mezzanine::Physics::Collision const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Collision_GetProxyA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetProxyA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetProxyA",1,"Mezzanine::Physics::Collision const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetProxyA",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  result = (Mezzanine::Physics::CollidableProxy *)((Mezzanine::Physics::Collision const *)arg1)->GetProxyA();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetProxyB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetProxyB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetProxyB",1,"Mezzanine::Physics::Collision const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetProxyB",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  result = (Mezzanine::Physics::CollidableProxy *)((Mezzanine::Physics::Collision const *)arg1)->GetProxyB();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetObjectA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::WorldObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetObjectA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetObjectA",1,"Mezzanine::Physics::Collision const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetObjectA",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  result = (Mezzanine::WorldObject *)((Mezzanine::Physics::Collision const *)arg1)->GetObjectA();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetObjectB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::WorldObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetObjectB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetObjectB",1,"Mezzanine::Physics::Collision const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetObjectB",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  result = (Mezzanine::WorldObject *)((Mezzanine::Physics::Collision const *)arg1)->GetObjectB();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__WorldObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_PairsMatch__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::WorldObject *arg2 = (Mezzanine::WorldObject *) 0 ;
  Mezzanine::WorldObject *arg3 = (Mezzanine::WorldObject *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::PairsMatch",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::PairsMatch",1,"Mezzanine::Physics::Collision const *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::PairsMatch",2,"Mezzanine::WorldObject *");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::Collision::PairsMatch",3,"Mezzanine::WorldObject *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_PairsMatch",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__WorldObject,0))){
    SWIG_fail_ptr("Collision_PairsMatch",2,SWIGTYPE_p_Mezzanine__WorldObject);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__WorldObject,0))){
    SWIG_fail_ptr("Collision_PairsMatch",3,SWIGTYPE_p_Mezzanine__WorldObject);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::Collision const *)arg1)->PairsMatch(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_PairsMatch__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg3 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::PairsMatch",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::PairsMatch",1,"Mezzanine::Physics::Collision const *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::PairsMatch",2,"Mezzanine::Physics::CollidableProxy *");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::Collision::PairsMatch",3,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_PairsMatch",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("Collision_PairsMatch",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("Collision_PairsMatch",3,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::Collision const *)arg1)->PairsMatch(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_PairsMatch(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Collision, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldObject, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__WorldObject, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_Collision_PairsMatch__SWIG_0(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Collision, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollidableProxy, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_Collision_PairsMatch__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Collision_PairsMatch'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Collision::PairsMatch(Mezzanine::WorldObject *,Mezzanine::WorldObject *) const\n"
    "    Mezzanine::Physics::Collision::PairsMatch(Mezzanine::Physics::CollidableProxy *,Mezzanine::Physics::CollidableProxy *) const\n");
  lua_error(L);return 0;
}


static int _wrap_Collision_Update(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::Update",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::Update",1,"Mezzanine::Physics::Collision *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_Update",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  (arg1)->Update();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetNumContactPoints(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetNumContactPoints",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetNumContactPoints",1,"Mezzanine::Physics::Collision *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetNumContactPoints",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  result = (Mezzanine::Whole)(arg1)->GetNumContactPoints();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetWorldLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetWorldLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetWorldLocation",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetWorldLocation",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetWorldLocation",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (arg1)->GetWorldLocation((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetLocalALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetLocalALocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetLocalALocation",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetLocalALocation",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetLocalALocation",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (arg1)->GetLocalALocation((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetLocalBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetLocalBLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetLocalBLocation",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetLocalBLocation",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetLocalBLocation",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (arg1)->GetLocalBLocation((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetNormal(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetNormal",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetNormal",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetNormal",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetNormal",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (arg1)->GetNormal((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetAppliedImpulse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetAppliedImpulse",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetAppliedImpulse",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetAppliedImpulse",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetAppliedImpulse",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Real)(arg1)->GetAppliedImpulse((Mezzanine::Whole const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetDistance(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetDistance",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetDistance",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetDistance",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetDistance",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Real)(arg1)->GetDistance((Mezzanine::Whole const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision_GetAge(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::GetAge",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetAge",1,"Mezzanine::Physics::Collision *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::GetAge",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision_GetAge",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Whole)(arg1)->GetAge((Mezzanine::Whole const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision__SetProxyA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::_SetProxyA",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::_SetProxyA",1,"Mezzanine::Physics::Collision *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::_SetProxyA",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision__SetProxyA",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("Collision__SetProxyA",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->_SetProxyA(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Collision__SetProxyB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) 0 ;
  Mezzanine::Physics::CollidableProxy *arg2 = (Mezzanine::Physics::CollidableProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Collision::_SetProxyB",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Collision::_SetProxyB",1,"Mezzanine::Physics::Collision *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Collision::_SetProxyB",2,"Mezzanine::Physics::CollidableProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Collision,0))){
    SWIG_fail_ptr("Collision__SetProxyB",1,SWIGTYPE_p_Mezzanine__Physics__Collision);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0))){
    SWIG_fail_ptr("Collision__SetProxyB",2,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy);
  }
  
  (arg1)->_SetProxyB(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Collision(void *obj) {
Mezzanine::Physics::Collision *arg1 = (Mezzanine::Physics::Collision *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_Collision_methods[] = {
    {"GetProxyA", _wrap_Collision_GetProxyA}, 
    {"GetProxyB", _wrap_Collision_GetProxyB}, 
    {"GetObjectA", _wrap_Collision_GetObjectA}, 
    {"GetObjectB", _wrap_Collision_GetObjectB}, 
    {"PairsMatch", _wrap_Collision_PairsMatch}, 
    {"Update", _wrap_Collision_Update}, 
    {"GetNumContactPoints", _wrap_Collision_GetNumContactPoints}, 
    {"GetWorldLocation", _wrap_Collision_GetWorldLocation}, 
    {"GetLocalALocation", _wrap_Collision_GetLocalALocation}, 
    {"GetLocalBLocation", _wrap_Collision_GetLocalBLocation}, 
    {"GetNormal", _wrap_Collision_GetNormal}, 
    {"GetAppliedImpulse", _wrap_Collision_GetAppliedImpulse}, 
    {"GetDistance", _wrap_Collision_GetDistance}, 
    {"GetAge", _wrap_Collision_GetAge}, 
    {"_SetProxyA", _wrap_Collision__SetProxyA}, 
    {"_SetProxyB", _wrap_Collision__SetProxyB}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_Collision_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_Collision_bases[] = {0};
static const char *swig_Mezzanine_Physics_Collision_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_Collision = { "Collision", &SWIGTYPE_p_Mezzanine__Physics__Collision,_wrap_new_Collision, swig_delete_Collision, swig_Mezzanine_Physics_Collision_methods, swig_Mezzanine_Physics_Collision_attributes, swig_Mezzanine_Physics_Collision_bases, swig_Mezzanine_Physics_Collision_base_names };

static int _wrap_new_CompoundCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CompoundCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape",1,1)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape",1,"Mezzanine::String const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  result = (Mezzanine::Physics::CompoundCollisionShape *)new Mezzanine::Physics::CompoundCollisionShape((Mezzanine::String const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CompoundCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btCompoundShape *arg2 = (btCompoundShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CompoundCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape",2,"btCompoundShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btCompoundShape,0))){
    SWIG_fail_ptr("new_CompoundCollisionShape",2,SWIGTYPE_p_btCompoundShape);
  }
  
  result = (Mezzanine::Physics::CompoundCollisionShape *)new Mezzanine::Physics::CompoundCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CompoundCollisionShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      return _wrap_new_CompoundCollisionShape__SWIG_0(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btCompoundShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_CompoundCollisionShape__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_CompoundCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape(Mezzanine::String const &)\n"
    "    Mezzanine::Physics::CompoundCollisionShape::CompoundCollisionShape(Mezzanine::String const &,btCompoundShape *)\n");
  lua_error(L);return 0;
}


static int _wrap_CompoundCollisionShape_AddChildShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Quaternion *arg4 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",1,"Mezzanine::Physics::CompoundCollisionShape *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",2,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",4,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",4,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->AddChildShape(arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Quaternion const &)*arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_AddChildShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",1,"Mezzanine::Physics::CompoundCollisionShape *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",2,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",3,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->AddChildShape(arg2,(Mezzanine::Physics::Vector3 const &)*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_AddChildShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Transform *arg3 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",1,"Mezzanine::Physics::CompoundCollisionShape *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",2,"Mezzanine::Physics::CollisionShape *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::AddChildShape",3,"Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Transform,0))){
    SWIG_fail_ptr("CompoundCollisionShape_AddChildShape",3,SWIGTYPE_p_Transform);
  }
  
  (arg1)->AddChildShape(arg2,(Transform const &)*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_AddChildShape(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_CompoundCollisionShape_AddChildShape__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_CompoundCollisionShape_AddChildShape__SWIG_2(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_CompoundCollisionShape_AddChildShape__SWIG_0(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CompoundCollisionShape_AddChildShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CompoundCollisionShape::AddChildShape(Mezzanine::Physics::CollisionShape *,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::CompoundCollisionShape::AddChildShape(Mezzanine::Physics::CollisionShape *,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CompoundCollisionShape::AddChildShape(Mezzanine::Physics::CollisionShape *,Transform const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CompoundCollisionShape_GetNumChildren(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::GetNumChildren",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::GetNumChildren",1,"Mezzanine::Physics::CompoundCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_GetNumChildren",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::Physics::CompoundCollisionShape const *)arg1)->GetNumChildren();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_GetChild(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Whole arg2 ;
  Mezzanine::Physics::CollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::GetChild",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::GetChild",1,"Mezzanine::Physics::CompoundCollisionShape const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::GetChild",2,"Mezzanine::Whole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_GetChild",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
  result = (Mezzanine::Physics::CollisionShape *)((Mezzanine::Physics::CompoundCollisionShape const *)arg1)->GetChild(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_RemoveChildShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape",1,"Mezzanine::Physics::CompoundCollisionShape *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_RemoveChildShape",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_RemoveChildShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->RemoveChildShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_RemoveChildShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape",1,"Mezzanine::Physics::CompoundCollisionShape *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_RemoveChildShape",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->RemoveChildShape((Mezzanine::Whole const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_RemoveChildShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_CompoundCollisionShape_RemoveChildShape__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_CompoundCollisionShape_RemoveChildShape__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'CompoundCollisionShape_RemoveChildShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape(Mezzanine::Physics::CollisionShape *)\n"
    "    Mezzanine::Physics::CompoundCollisionShape::RemoveChildShape(Mezzanine::Whole const &)\n");
  lua_error(L);return 0;
}


static int _wrap_CompoundCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::GetType",1,"Mezzanine::Physics::CompoundCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::CompoundCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_GetBulletCompoundShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  btCompoundShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::GetBulletCompoundShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::GetBulletCompoundShape",1,"Mezzanine::Physics::CompoundCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_GetBulletCompoundShape",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  result = (btCompoundShape *)((Mezzanine::Physics::CompoundCollisionShape const *)arg1)->GetBulletCompoundShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCompoundShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::CompoundCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CompoundCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::CompoundCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::CompoundCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CompoundCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,0))){
    SWIG_fail_ptr("CompoundCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CompoundCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CompoundCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CompoundCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::CompoundCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CompoundCollisionShape(void *obj) {
Mezzanine::Physics::CompoundCollisionShape *arg1 = (Mezzanine::Physics::CompoundCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CompoundCollisionShape_methods[] = {
    {"AddChildShape", _wrap_CompoundCollisionShape_AddChildShape}, 
    {"GetNumChildren", _wrap_CompoundCollisionShape_GetNumChildren}, 
    {"GetChild", _wrap_CompoundCollisionShape_GetChild}, 
    {"RemoveChildShape", _wrap_CompoundCollisionShape_RemoveChildShape}, 
    {"GetType", _wrap_CompoundCollisionShape_GetType}, 
    {"GetBulletCompoundShape", _wrap_CompoundCollisionShape_GetBulletCompoundShape}, 
    {"ProtoSerialize", _wrap_CompoundCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_CompoundCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CompoundCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CompoundCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_CompoundCollisionShape_base_names[] = {"Mezzanine::Physics::CollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CompoundCollisionShape = { "CompoundCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__CompoundCollisionShape,_wrap_new_CompoundCollisionShape, swig_delete_CompoundCollisionShape, swig_Mezzanine_Physics_CompoundCollisionShape_methods, swig_Mezzanine_Physics_CompoundCollisionShape_attributes, swig_Mezzanine_Physics_CompoundCollisionShape_bases, swig_Mezzanine_Physics_CompoundCollisionShape_base_names };

static int _wrap_new_ConeCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Physics::ConeCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",3,"Mezzanine::Real const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",4,"Mezzanine::Physics::Vector3 const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_ConeCollisionShape",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::ConeCollisionShape *)new Mezzanine::Physics::ConeCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConeCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::StandardAxis arg4 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Physics::ConeCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",3,"Mezzanine::Real const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",4,"Mezzanine::StandardAxis");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  arg4 = (Mezzanine::StandardAxis)(int)lua_tonumber(L, 4);
  result = (Mezzanine::Physics::ConeCollisionShape *)new Mezzanine::Physics::ConeCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConeCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btConeShape *arg2 = (btConeShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::ConeCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",2,"btConeShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btConeShape,0))){
    SWIG_fail_ptr("new_ConeCollisionShape",2,SWIGTYPE_p_btConeShape);
  }
  
  result = (Mezzanine::Physics::ConeCollisionShape *)new Mezzanine::Physics::ConeCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConeCollisionShape__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::ConeCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_ConeCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::ConeCollisionShape *)new Mezzanine::Physics::ConeCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConeCollisionShape(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_ConeCollisionShape__SWIG_3(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btConeShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_ConeCollisionShape__SWIG_2(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_ConeCollisionShape__SWIG_0(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_ConeCollisionShape__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ConeCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape(Mezzanine::String const &,Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape(Mezzanine::String const &,Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::StandardAxis)\n"
    "    Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape(Mezzanine::String const &,btConeShape *)\n"
    "    Mezzanine::Physics::ConeCollisionShape::ConeCollisionShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_ConeCollisionShape_GetRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetRadius",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetRadius",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetRadius",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetRadius();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetHeight(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetHeight",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetHeight",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetHeight",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetHeight();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetCleanRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetCleanRadius",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetCleanRadius",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetCleanRadius",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetCleanRadius();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetCleanHeight(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetCleanHeight",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetCleanHeight",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetCleanHeight",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetCleanHeight();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetRadiusScaling(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetRadiusScaling",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetRadiusScaling",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetRadiusScaling",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetRadiusScaling();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetHeightScaling(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetHeightScaling",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetHeightScaling",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetHeightScaling",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetHeightScaling();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetUpAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetUpAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetUpAxis",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetUpAxis",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = ((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetUpAxis();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetUpStandardAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::StandardAxis result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetUpStandardAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetUpStandardAxis",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetUpStandardAxis",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::StandardAxis)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetUpStandardAxis();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetType",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_GetBulletConeShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  btConeShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::GetBulletConeShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::GetBulletConeShape",1,"Mezzanine::Physics::ConeCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_GetBulletConeShape",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  result = (btConeShape *)((Mezzanine::Physics::ConeCollisionShape const *)arg1)->GetBulletConeShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btConeShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::ConeCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("ConeCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::ConeCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::ConeCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConeCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,0))){
    SWIG_fail_ptr("ConeCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("ConeCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConeCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConeCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::ConeCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ConeCollisionShape(void *obj) {
Mezzanine::Physics::ConeCollisionShape *arg1 = (Mezzanine::Physics::ConeCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_ConeCollisionShape_methods[] = {
    {"GetRadius", _wrap_ConeCollisionShape_GetRadius}, 
    {"GetHeight", _wrap_ConeCollisionShape_GetHeight}, 
    {"GetCleanRadius", _wrap_ConeCollisionShape_GetCleanRadius}, 
    {"GetCleanHeight", _wrap_ConeCollisionShape_GetCleanHeight}, 
    {"GetRadiusScaling", _wrap_ConeCollisionShape_GetRadiusScaling}, 
    {"GetHeightScaling", _wrap_ConeCollisionShape_GetHeightScaling}, 
    {"GetUpAxis", _wrap_ConeCollisionShape_GetUpAxis}, 
    {"GetUpStandardAxis", _wrap_ConeCollisionShape_GetUpStandardAxis}, 
    {"GetType", _wrap_ConeCollisionShape_GetType}, 
    {"GetBulletConeShape", _wrap_ConeCollisionShape_GetBulletConeShape}, 
    {"ProtoSerialize", _wrap_ConeCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_ConeCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_ConeCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_ConeCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_ConeCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_ConeCollisionShape = { "ConeCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__ConeCollisionShape,_wrap_new_ConeCollisionShape, swig_delete_ConeCollisionShape, swig_Mezzanine_Physics_ConeCollisionShape_methods, swig_Mezzanine_Physics_ConeCollisionShape_attributes, swig_Mezzanine_Physics_ConeCollisionShape_bases, swig_Mezzanine_Physics_ConeCollisionShape_base_names };

static int _wrap_Transform_Location_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Vector3 *arg2 = (Mezzanine::Vector3 *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Location",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::Location",1,"Mezzanine::Transform *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Transform::Location",2,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_Location_set",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Transform_Location_set",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  if (arg1) (arg1)->Location = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_Location_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Location",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::Location",1,"Mezzanine::Transform *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_Location_get",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Vector3 *)& ((arg1)->Location);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_Rotation_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Quaternion *arg2 = (Mezzanine::Quaternion *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Rotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::Rotation",1,"Mezzanine::Transform *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Transform::Rotation",2,"Mezzanine::Quaternion *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_Rotation_set",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Transform_Rotation_set",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  if (arg1) (arg1)->Rotation = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_Rotation_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Quaternion *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Rotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::Rotation",1,"Mezzanine::Transform *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_Rotation_get",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Quaternion *)& ((arg1)->Rotation);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Quaternion,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Transform__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Transform",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Transform::Transform",1,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::Transform",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Transform",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Transform",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Transform *)new Mezzanine::Transform((Mezzanine::Vector3 const &)*arg1,(Mezzanine::Quaternion const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Transform__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Transform",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Transform::Transform",1,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Transform",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Transform *)new Mezzanine::Transform((Mezzanine::Vector3 const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Transform__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Transform",0,0)
  result = (Mezzanine::Transform *)new Mezzanine::Transform();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Transform__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  btTransform *arg1 = 0 ;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Transform",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Transform::Transform",1,"btTransform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_btTransform,0))){
    SWIG_fail_ptr("new_Transform",1,SWIGTYPE_p_btTransform);
  }
  
  result = (Mezzanine::Transform *)new Mezzanine::Transform((btTransform const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Transform__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = 0 ;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::Transform",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Transform::Transform",1,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Transform",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Transform *)new Mezzanine::Transform((Mezzanine::Transform const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Transform(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_Transform__SWIG_2(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Transform__SWIG_1(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_btTransform, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Transform__SWIG_3(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Transform__SWIG_4(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_Transform__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Transform'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Transform::Transform(Mezzanine::Vector3 const &,Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Transform::Transform(Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Transform::Transform()\n"
    "    Mezzanine::Transform::Transform(btTransform const &)\n"
    "    Mezzanine::Transform::Transform(Mezzanine::Transform const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Transform_SetIdentity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::SetIdentity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::SetIdentity",1,"Mezzanine::Transform *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_SetIdentity",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetIdentity();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_GetBulletTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  btTransform result;
  
  SWIG_check_num_args("Mezzanine::Transform::GetBulletTransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::GetBulletTransform",1,"Mezzanine::Transform const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_GetBulletTransform",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = ((Mezzanine::Transform const *)arg1)->GetBulletTransform();
  {
    btTransform * resultptr = new btTransform((const btTransform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_btTransform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_ExtractBulletTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  btTransform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::ExtractBulletTransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::ExtractBulletTransform",1,"Mezzanine::Transform *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::ExtractBulletTransform",2,"btTransform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_ExtractBulletTransform",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btTransform,0))){
    SWIG_fail_ptr("Transform_ExtractBulletTransform",2,SWIGTYPE_p_btTransform);
  }
  
  (arg1)->ExtractBulletTransform((btTransform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::ProtoSerialize",1,"Mezzanine::Transform const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Transform_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Transform const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Transform::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::ProtoDeSerialize",1,"Mezzanine::Transform *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Transform_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Transform::SerializableName",0,0)
  result = Mezzanine::Transform::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform___sub(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Transform::operator -",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::operator -",1,"Mezzanine::Transform const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::operator -",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___sub",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___sub",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = ((Mezzanine::Transform const *)arg1)->operator -((Mezzanine::Transform const &)*arg2);
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform___add(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Transform::operator +",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::operator +",1,"Mezzanine::Transform const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::operator +",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___add",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___add",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = ((Mezzanine::Transform const *)arg1)->operator +((Mezzanine::Transform const &)*arg2);
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform___mul(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Transform::operator *",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::operator *",1,"Mezzanine::Transform const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Transform::operator *",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___mul",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  result = ((Mezzanine::Transform const *)arg1)->operator *(arg2);
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform___div(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Transform::operator /",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::operator /",1,"Mezzanine::Transform const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Transform::operator /",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___div",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  result = ((Mezzanine::Transform const *)arg1)->operator /(arg2);
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Transform___le(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Transform *arg1 = (Mezzanine::Transform *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Transform::operator <=",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Transform::operator <=",1,"Mezzanine::Transform const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Transform::operator <=",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___le",1,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Transform___le",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Transform const *)arg1)->operator <=((Mezzanine::Transform const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Transform(void *obj) {
Mezzanine::Transform *arg1 = (Mezzanine::Transform *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Transform_methods[] = {
    {"SetIdentity", _wrap_Transform_SetIdentity}, 
    {"GetBulletTransform", _wrap_Transform_GetBulletTransform}, 
    {"ExtractBulletTransform", _wrap_Transform_ExtractBulletTransform}, 
    {"ProtoSerialize", _wrap_Transform_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Transform_ProtoDeSerialize}, 
    {"__sub", _wrap_Transform___sub}, 
    {"__add", _wrap_Transform___add}, 
    {"__mul", _wrap_Transform___mul}, 
    {"__div", _wrap_Transform___div}, 
    {"__le", _wrap_Transform___le}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Transform_attributes[] = {
    { "Location", _wrap_Transform_Location_get, _wrap_Transform_Location_set},
    { "Rotation", _wrap_Transform_Rotation_get, _wrap_Transform_Rotation_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Transform_bases[] = {0};
static const char *swig_Mezzanine_Transform_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Transform = { "Transform", &SWIGTYPE_p_Mezzanine__Transform,_wrap_new_Transform, swig_delete_Transform, swig_Mezzanine_Transform_methods, swig_Mezzanine_Transform_attributes, swig_Mezzanine_Transform_bases, swig_Mezzanine_Transform_base_names };

static int _wrap_ConstraintParamAsString(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConstraintParam arg1 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConstraintParamAsString",1,1)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConstraintParamAsString",1,"Mezzanine::Physics::ConstraintParam");
  arg1 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 1);
  result = Mezzanine::Physics::ConstraintParamAsString(arg1);
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StringAsConstraintParam(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String arg1 ;
  Mezzanine::Physics::ConstraintParam result;
  
  SWIG_check_num_args("Mezzanine::Physics::StringAsConstraintParam",1,1)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::StringAsConstraintParam",1,"Mezzanine::String");
  (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1));
  result = (Mezzanine::Physics::ConstraintParam)Mezzanine::Physics::StringAsConstraintParam(arg1);
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConstraintParamCount_get(lua_State* L) {
  int SWIG_arg = 0;
  int result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConstraintParamCount",0,0)
  result = (int)(int)Mezzanine::Physics::ConstraintParamCount;
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_char4ToAxis(lua_State* L) {
  int SWIG_arg = 0;
  char arg1 ;
  int result;
  
  SWIG_check_num_args("Mezzanine::Physics::char4ToAxis",1,1)
  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::char4ToAxis",1,"char");
  arg1 = (lua_tostring(L, 1))[0];
  result = (int)Mezzanine::Physics::char4ToAxis(arg1);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_GetProxyA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::GetProxyA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetProxyA",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_GetProxyA",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)((Mezzanine::Physics::Constraint const *)arg1)->GetProxyA();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_GetProxyB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::GetProxyB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetProxyB",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_GetProxyB",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)((Mezzanine::Physics::Constraint const *)arg1)->GetProxyB();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ValidParamOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ValidParamOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ValidParamOnAxis",1,"Mezzanine::Physics::Constraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ValidParamOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ValidParamOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = ((Mezzanine::Physics::Constraint const *)arg1)->ValidParamOnAxis(arg2);
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ValidLinearAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ValidLinearAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ValidLinearAxis",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ValidLinearAxis",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = ((Mezzanine::Physics::Constraint const *)arg1)->ValidLinearAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ValidAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ValidAngularAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ValidAngularAxis",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ValidAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = ((Mezzanine::Physics::Constraint const *)arg1)->ValidAngularAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_HasParamBeenSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::HasParamBeenSet",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::HasParamBeenSet",1,"Mezzanine::Physics::Constraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::HasParamBeenSet",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Constraint::HasParamBeenSet",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_HasParamBeenSet",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Constraint const *)arg1)->HasParamBeenSet(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ValidAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ValidAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ValidAxis",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ValidAxis",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = ((Mezzanine::Physics::Constraint const *)arg1)->ValidAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_IsParamValidOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::IsParamValidOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::IsParamValidOnAxis",1,"Mezzanine::Physics::Constraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::IsParamValidOnAxis",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Constraint::IsParamValidOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_IsParamValidOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Constraint const *)arg1)->IsParamValidOnAxis(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ValidParams(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ValidParams",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ValidParams",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ValidParams",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = ((Mezzanine::Physics::Constraint const *)arg1)->ValidParams();
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_SetParam__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  Mezzanine::Real arg3 ;
  int arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::SetParam",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",1,"Mezzanine::Physics::Constraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",3,"Mezzanine::Real");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",4,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_SetParam",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  arg4 = (int)lua_tonumber(L, 4);
  (arg1)->SetParam(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_SetParam__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::SetParam",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",1,"Mezzanine::Physics::Constraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Constraint::SetParam",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_SetParam",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetParam(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_SetParam(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Constraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_Constraint_SetParam__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Constraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_Constraint_SetParam__SWIG_0(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Constraint_SetParam'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Constraint::SetParam(Mezzanine::Physics::ConstraintParam,Mezzanine::Real,int)\n"
    "    Mezzanine::Physics::Constraint::SetParam(Mezzanine::Physics::ConstraintParam,Mezzanine::Real)\n");
  lua_error(L);return 0;
}


static int _wrap_Constraint_GetParam__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::GetParam",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetParam",1,"Mezzanine::Physics::Constraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetParam",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetParam",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_GetParam",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Real)((Mezzanine::Physics::Constraint const *)arg1)->GetParam(arg2,arg3);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_GetParam__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::GetParam",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetParam",1,"Mezzanine::Physics::Constraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetParam",2,"Mezzanine::Physics::ConstraintParam");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_GetParam",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Constraint const *)arg1)->GetParam(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_GetParam(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Constraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_Constraint_GetParam__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__Constraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_Constraint_GetParam__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Constraint_GetParam'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Constraint::GetParam(Mezzanine::Physics::ConstraintParam,int) const\n"
    "    Mezzanine::Physics::Constraint::GetParam(Mezzanine::Physics::ConstraintParam) const\n");
  lua_error(L);return 0;
}


static int _wrap_Constraint_GetConstraintBase(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  btTypedConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::GetConstraintBase",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::GetConstraintBase",1,"Mezzanine::Physics::Constraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_GetConstraintBase",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  result = (btTypedConstraint *)((Mezzanine::Physics::Constraint const *)arg1)->GetConstraintBase();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btTypedConstraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ProtoSerialize",1,"Mezzanine::Physics::Constraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Constraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::Constraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ProtoDeSerialize",1,"Mezzanine::Physics::Constraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Constraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Constraint,0))){
    SWIG_fail_ptr("Constraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Constraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Constraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Constraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::Constraint::SerializableName",0,0)
  result = Mezzanine::Physics::Constraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Constraint(void *obj) {
Mezzanine::Physics::Constraint *arg1 = (Mezzanine::Physics::Constraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_Constraint_methods[] = {
    {"GetProxyA", _wrap_Constraint_GetProxyA}, 
    {"GetProxyB", _wrap_Constraint_GetProxyB}, 
    {"ValidParamOnAxis", _wrap_Constraint_ValidParamOnAxis}, 
    {"ValidLinearAxis", _wrap_Constraint_ValidLinearAxis}, 
    {"ValidAngularAxis", _wrap_Constraint_ValidAngularAxis}, 
    {"HasParamBeenSet", _wrap_Constraint_HasParamBeenSet}, 
    {"ValidAxis", _wrap_Constraint_ValidAxis}, 
    {"IsParamValidOnAxis", _wrap_Constraint_IsParamValidOnAxis}, 
    {"ValidParams", _wrap_Constraint_ValidParams}, 
    {"SetParam", _wrap_Constraint_SetParam}, 
    {"GetParam", _wrap_Constraint_GetParam}, 
    {"GetConstraintBase", _wrap_Constraint_GetConstraintBase}, 
    {"ProtoSerialize", _wrap_Constraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Constraint_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_Constraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_Constraint_bases[] = {0};
static const char *swig_Mezzanine_Physics_Constraint_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_Constraint = { "Constraint", &SWIGTYPE_p_Mezzanine__Physics__Constraint,0, swig_delete_Constraint, swig_Mezzanine_Physics_Constraint_methods, swig_Mezzanine_Physics_Constraint_attributes, swig_Mezzanine_Physics_Constraint_bases, swig_Mezzanine_Physics_Constraint_base_names };

static int _wrap_new_ConvexHullCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  std::vector< Mezzanine::Physics::Vector3 > *arg2 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",2,"std::vector< Mezzanine::Physics::Vector3 > const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t,0))){
    SWIG_fail_ptr("new_ConvexHullCollisionShape",2,SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t);
  }
  
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)new Mezzanine::Physics::ConvexHullCollisionShape((Mezzanine::String const &)*arg1,(std::vector< Mezzanine::Physics::Vector3 > const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConvexHullCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btConvexHullShape *arg2 = (btConvexHullShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",2,"btConvexHullShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btConvexHullShape,0))){
    SWIG_fail_ptr("new_ConvexHullCollisionShape",2,SWIGTYPE_p_btConvexHullShape);
  }
  
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)new Mezzanine::Physics::ConvexHullCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConvexHullCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::ConvexHullCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_ConvexHullCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::ConvexHullCollisionShape *)new Mezzanine::Physics::ConvexHullCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ConvexHullCollisionShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_ConvexHullCollisionShape__SWIG_2(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btConvexHullShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_ConvexHullCollisionShape__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_ConvexHullCollisionShape__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_ConvexHullCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape(Mezzanine::String const &,std::vector< Mezzanine::Physics::Vector3 > const &)\n"
    "    Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape(Mezzanine::String const &,btConvexHullShape *)\n"
    "    Mezzanine::Physics::ConvexHullCollisionShape::ConvexHullCollisionShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_ConvexHullCollisionShape_AddPoint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::AddPoint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::AddPoint",1,"Mezzanine::Physics::ConvexHullCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::AddPoint",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_AddPoint",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_AddPoint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->AddPoint((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_GetUnscaledPoint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::GetUnscaledPoint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetUnscaledPoint",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetUnscaledPoint",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_GetUnscaledPoint",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->GetUnscaledPoint((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_GetPoint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::GetPoint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetPoint",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetPoint",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_GetPoint",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->GetPoint((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_GetNumPoints(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::GetNumPoints",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetNumPoints",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_GetNumPoints",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->GetNumPoints();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_IsInside(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::IsInside",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::IsInside",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::IsInside",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::IsInside",3,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_IsInside",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_IsInside",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  result = (Mezzanine::Boole)((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->IsInside((Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Real const &)*arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetType",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_GetBulletHullShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  btConvexHullShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::GetBulletHullShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::GetBulletHullShape",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_GetBulletHullShape",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  result = (btConvexHullShape *)((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->GetBulletHullShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btConvexHullShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::ConvexHullCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::ConvexHullCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::ConvexHullCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::ConvexHullCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("ConvexHullCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ConvexHullCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::ConvexHullCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::ConvexHullCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ConvexHullCollisionShape(void *obj) {
Mezzanine::Physics::ConvexHullCollisionShape *arg1 = (Mezzanine::Physics::ConvexHullCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_ConvexHullCollisionShape_methods[] = {
    {"AddPoint", _wrap_ConvexHullCollisionShape_AddPoint}, 
    {"GetUnscaledPoint", _wrap_ConvexHullCollisionShape_GetUnscaledPoint}, 
    {"GetPoint", _wrap_ConvexHullCollisionShape_GetPoint}, 
    {"GetNumPoints", _wrap_ConvexHullCollisionShape_GetNumPoints}, 
    {"IsInside", _wrap_ConvexHullCollisionShape_IsInside}, 
    {"GetType", _wrap_ConvexHullCollisionShape_GetType}, 
    {"GetBulletHullShape", _wrap_ConvexHullCollisionShape_GetBulletHullShape}, 
    {"ProtoSerialize", _wrap_ConvexHullCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_ConvexHullCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_ConvexHullCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_ConvexHullCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_ConvexHullCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_ConvexHullCollisionShape = { "ConvexHullCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__ConvexHullCollisionShape,_wrap_new_ConvexHullCollisionShape, swig_delete_ConvexHullCollisionShape, swig_Mezzanine_Physics_ConvexHullCollisionShape_methods, swig_Mezzanine_Physics_ConvexHullCollisionShape_attributes, swig_Mezzanine_Physics_ConvexHullCollisionShape_bases, swig_Mezzanine_Physics_ConvexHullCollisionShape_base_names };

static int _wrap_new_CylinderCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Physics::CylinderCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",3,"Mezzanine::Real const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",4,"Mezzanine::Physics::Vector3 const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_CylinderCollisionShape",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::CylinderCollisionShape *)new Mezzanine::Physics::CylinderCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CylinderCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real *arg3 = 0 ;
  Mezzanine::StandardAxis arg4 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Real temp3 ;
  Mezzanine::Physics::CylinderCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",4,4)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",3,"Mezzanine::Real const &");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",4,"Mezzanine::StandardAxis");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  temp3=(Mezzanine::Real)lua_tonumber(L,3); arg3=&temp3;
  arg4 = (Mezzanine::StandardAxis)(int)lua_tonumber(L, 4);
  result = (Mezzanine::Physics::CylinderCollisionShape *)new Mezzanine::Physics::CylinderCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2,(Mezzanine::Real const &)*arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CylinderCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CylinderCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",3,3)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",3,"Mezzanine::Physics::Vector3 const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_CylinderCollisionShape",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_CylinderCollisionShape",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::CylinderCollisionShape *)new Mezzanine::Physics::CylinderCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Physics::Vector3 const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CylinderCollisionShape__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::StandardAxis arg3 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CylinderCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",3,3)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",3,"Mezzanine::StandardAxis");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_CylinderCollisionShape",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::StandardAxis)(int)lua_tonumber(L, 3);
  result = (Mezzanine::Physics::CylinderCollisionShape *)new Mezzanine::Physics::CylinderCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Physics::Vector3 const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CylinderCollisionShape__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btCylinderShape *arg2 = (btCylinderShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::CylinderCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",2,"btCylinderShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btCylinderShape,0))){
    SWIG_fail_ptr("new_CylinderCollisionShape",2,SWIGTYPE_p_btCylinderShape);
  }
  
  result = (Mezzanine::Physics::CylinderCollisionShape *)new Mezzanine::Physics::CylinderCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CylinderCollisionShape__SWIG_5(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::CylinderCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_CylinderCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::CylinderCollisionShape *)new Mezzanine::Physics::CylinderCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_CylinderCollisionShape(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_CylinderCollisionShape__SWIG_5(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btCylinderShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_CylinderCollisionShape__SWIG_4(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_CylinderCollisionShape__SWIG_2(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_new_CylinderCollisionShape__SWIG_3(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_CylinderCollisionShape__SWIG_0(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_CylinderCollisionShape__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_CylinderCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape(Mezzanine::String const &,Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape(Mezzanine::String const &,Mezzanine::Real const &,Mezzanine::Real const &,Mezzanine::StandardAxis)\n"
    "    Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape(Mezzanine::String const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape(Mezzanine::String const &,Mezzanine::Physics::Vector3 const &,Mezzanine::StandardAxis)\n"
    "    Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape(Mezzanine::String const &,btCylinderShape *)\n"
    "    Mezzanine::Physics::CylinderCollisionShape::CylinderCollisionShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_CylinderCollisionShape_CreateHalfExtents(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::StandardAxis arg3 ;
  Mezzanine::Real temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::CreateHalfExtents",3,3)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CreateHalfExtents",1,"Mezzanine::Real const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CreateHalfExtents",2,"Mezzanine::Real const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::CreateHalfExtents",3,"Mezzanine::StandardAxis");
  temp1=(Mezzanine::Real)lua_tonumber(L,1); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  arg3 = (Mezzanine::StandardAxis)(int)lua_tonumber(L, 3);
  result = Mezzanine::Physics::CylinderCollisionShape::CreateHalfExtents((float const &)*arg1,(float const &)*arg2,arg3);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_GetHalfExtents(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::GetHalfExtents",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::GetHalfExtents",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_GetHalfExtents",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  result = ((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->GetHalfExtents();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_GetHalfExtentsWithMargin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::GetHalfExtentsWithMargin",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::GetHalfExtentsWithMargin",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_GetHalfExtentsWithMargin",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  result = ((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->GetHalfExtentsWithMargin();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_GetRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::GetRadius",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::GetRadius",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_GetRadius",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->GetRadius();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_GetUpAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::GetUpAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::GetUpAxis",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_GetUpAxis",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  result = ((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->GetUpAxis();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::GetType",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_GetBulletCylinderShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  btCylinderShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::GetBulletCylinderShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::GetBulletCylinderShape",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_GetBulletCylinderShape",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  result = (btCylinderShape *)((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->GetBulletCylinderShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCylinderShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::CylinderCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CylinderCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::CylinderCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::CylinderCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::CylinderCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,0))){
    SWIG_fail_ptr("CylinderCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("CylinderCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_CylinderCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::CylinderCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::CylinderCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_CylinderCollisionShape(void *obj) {
Mezzanine::Physics::CylinderCollisionShape *arg1 = (Mezzanine::Physics::CylinderCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_CylinderCollisionShape_methods[] = {
    {"GetHalfExtents", _wrap_CylinderCollisionShape_GetHalfExtents}, 
    {"GetHalfExtentsWithMargin", _wrap_CylinderCollisionShape_GetHalfExtentsWithMargin}, 
    {"GetRadius", _wrap_CylinderCollisionShape_GetRadius}, 
    {"GetUpAxis", _wrap_CylinderCollisionShape_GetUpAxis}, 
    {"GetType", _wrap_CylinderCollisionShape_GetType}, 
    {"GetBulletCylinderShape", _wrap_CylinderCollisionShape_GetBulletCylinderShape}, 
    {"ProtoSerialize", _wrap_CylinderCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_CylinderCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_CylinderCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_CylinderCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_CylinderCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_CylinderCollisionShape = { "CylinderCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__CylinderCollisionShape,_wrap_new_CylinderCollisionShape, swig_delete_CylinderCollisionShape, swig_Mezzanine_Physics_CylinderCollisionShape_methods, swig_Mezzanine_Physics_CylinderCollisionShape_attributes, swig_Mezzanine_Physics_CylinderCollisionShape_bases, swig_Mezzanine_Physics_CylinderCollisionShape_base_names };

static int _wrap_DualTransformConstraint_SetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SetPivotATransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotATransform",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotATransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotATransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotATransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_SetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SetPivotBTransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotBTransform",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotBTransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotBTransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotBTransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_GetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::GetPivotATransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::GetPivotATransform",1,"Mezzanine::Physics::DualTransformConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_GetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  result = ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->GetPivotATransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_GetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::GetPivotBTransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::GetPivotBTransform",1,"Mezzanine::Physics::DualTransformConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_GetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  result = ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->GetPivotBTransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_SetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SetPivotALocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotALocation",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotALocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotALocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotALocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_SetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SetPivotBLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotBLocation",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotBLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotBLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotBLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_GetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::GetPivotALocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::GetPivotALocation",1,"Mezzanine::Physics::DualTransformConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_GetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  result = ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->GetPivotALocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_GetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::GetPivotBLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::GetPivotBLocation",1,"Mezzanine::Physics::DualTransformConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_GetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  result = ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->GetPivotBLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_SetPivotARotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SetPivotARotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotARotation",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotARotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotARotation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotARotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetPivotARotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_SetPivotBRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SetPivotBRotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotBRotation",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::SetPivotBRotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotBRotation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("DualTransformConstraint_SetPivotBRotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetPivotBRotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_GetPivotARotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::GetPivotARotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::GetPivotARotation",1,"Mezzanine::Physics::DualTransformConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_GetPivotARotation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  result = ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->GetPivotARotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_GetPivotBRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::GetPivotBRotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::GetPivotBRotation",1,"Mezzanine::Physics::DualTransformConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_GetPivotBRotation",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  result = ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->GetPivotBRotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::ProtoSerialize",1,"Mezzanine::Physics::DualTransformConstraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("DualTransformConstraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::DualTransformConstraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::ProtoDeSerialize",1,"Mezzanine::Physics::DualTransformConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::DualTransformConstraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0))){
    SWIG_fail_ptr("DualTransformConstraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("DualTransformConstraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DualTransformConstraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::DualTransformConstraint::SerializableName",0,0)
  result = Mezzanine::Physics::DualTransformConstraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DualTransformConstraint(void *obj) {
Mezzanine::Physics::DualTransformConstraint *arg1 = (Mezzanine::Physics::DualTransformConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_DualTransformConstraint_methods[] = {
    {"SetPivotATransform", _wrap_DualTransformConstraint_SetPivotATransform}, 
    {"SetPivotBTransform", _wrap_DualTransformConstraint_SetPivotBTransform}, 
    {"GetPivotATransform", _wrap_DualTransformConstraint_GetPivotATransform}, 
    {"GetPivotBTransform", _wrap_DualTransformConstraint_GetPivotBTransform}, 
    {"SetPivotALocation", _wrap_DualTransformConstraint_SetPivotALocation}, 
    {"SetPivotBLocation", _wrap_DualTransformConstraint_SetPivotBLocation}, 
    {"GetPivotALocation", _wrap_DualTransformConstraint_GetPivotALocation}, 
    {"GetPivotBLocation", _wrap_DualTransformConstraint_GetPivotBLocation}, 
    {"SetPivotARotation", _wrap_DualTransformConstraint_SetPivotARotation}, 
    {"SetPivotBRotation", _wrap_DualTransformConstraint_SetPivotBRotation}, 
    {"GetPivotARotation", _wrap_DualTransformConstraint_GetPivotARotation}, 
    {"GetPivotBRotation", _wrap_DualTransformConstraint_GetPivotBRotation}, 
    {"ProtoSerialize", _wrap_DualTransformConstraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_DualTransformConstraint_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_DualTransformConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_DualTransformConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_DualTransformConstraint_base_names[] = {"Mezzanine::Physics::Constraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_DualTransformConstraint = { "DualTransformConstraint", &SWIGTYPE_p_Mezzanine__Physics__DualTransformConstraint,0, swig_delete_DualTransformConstraint, swig_Mezzanine_Physics_DualTransformConstraint_methods, swig_Mezzanine_Physics_DualTransformConstraint_attributes, swig_Mezzanine_Physics_DualTransformConstraint_bases, swig_Mezzanine_Physics_DualTransformConstraint_base_names };

static int _wrap_MeshCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MeshCollisionShape *arg1 = (Mezzanine::Physics::MeshCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::MeshCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MeshCollisionShape::GetType",1,"Mezzanine::Physics::MeshCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape,0))){
    SWIG_fail_ptr("MeshCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::MeshCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MeshCollisionShape_GetBulletConcaveShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MeshCollisionShape *arg1 = (Mezzanine::Physics::MeshCollisionShape *) 0 ;
  btConcaveShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MeshCollisionShape::GetBulletConcaveShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MeshCollisionShape::GetBulletConcaveShape",1,"Mezzanine::Physics::MeshCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape,0))){
    SWIG_fail_ptr("MeshCollisionShape_GetBulletConcaveShape",1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape);
  }
  
  result = (btConcaveShape *)((Mezzanine::Physics::MeshCollisionShape const *)arg1)->GetBulletConcaveShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btConcaveShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MeshCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MeshCollisionShape *arg1 = (Mezzanine::Physics::MeshCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MeshCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MeshCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::MeshCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::MeshCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape,0))){
    SWIG_fail_ptr("MeshCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("MeshCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::MeshCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MeshCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MeshCollisionShape *arg1 = (Mezzanine::Physics::MeshCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MeshCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MeshCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::MeshCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::MeshCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape,0))){
    SWIG_fail_ptr("MeshCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("MeshCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MeshCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::MeshCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::MeshCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_MeshCollisionShape(void *obj) {
Mezzanine::Physics::MeshCollisionShape *arg1 = (Mezzanine::Physics::MeshCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_MeshCollisionShape_methods[] = {
    {"GetType", _wrap_MeshCollisionShape_GetType}, 
    {"GetBulletConcaveShape", _wrap_MeshCollisionShape_GetBulletConcaveShape}, 
    {"ProtoSerialize", _wrap_MeshCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_MeshCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_MeshCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_MeshCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_MeshCollisionShape_base_names[] = {"Mezzanine::Physics::CollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_MeshCollisionShape = { "MeshCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__MeshCollisionShape,0, swig_delete_MeshCollisionShape, swig_Mezzanine_Physics_MeshCollisionShape_methods, swig_Mezzanine_Physics_MeshCollisionShape_attributes, swig_Mezzanine_Physics_MeshCollisionShape_bases, swig_Mezzanine_Physics_MeshCollisionShape_base_names };

static int _wrap_new_DynamicMeshCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btGImpactMeshShape *arg2 = (btGImpactMeshShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::DynamicMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::DynamicMeshCollisionShape::DynamicMeshCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::DynamicMeshCollisionShape::DynamicMeshCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::DynamicMeshCollisionShape::DynamicMeshCollisionShape",2,"btGImpactMeshShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btGImpactMeshShape,0))){
    SWIG_fail_ptr("new_DynamicMeshCollisionShape",2,SWIGTYPE_p_btGImpactMeshShape);
  }
  
  result = (Mezzanine::Physics::DynamicMeshCollisionShape *)new Mezzanine::Physics::DynamicMeshCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_DynamicMeshCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::DynamicMeshCollisionShape *arg1 = (Mezzanine::Physics::DynamicMeshCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::DynamicMeshCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::DynamicMeshCollisionShape::GetType",1,"Mezzanine::Physics::DynamicMeshCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,0))){
    SWIG_fail_ptr("DynamicMeshCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::DynamicMeshCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_DynamicMeshCollisionShape(void *obj) {
Mezzanine::Physics::DynamicMeshCollisionShape *arg1 = (Mezzanine::Physics::DynamicMeshCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_DynamicMeshCollisionShape_methods[] = {
    {"GetType", _wrap_DynamicMeshCollisionShape_GetType}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_DynamicMeshCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_DynamicMeshCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_DynamicMeshCollisionShape_base_names[] = {"Mezzanine::Physics::MeshCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_DynamicMeshCollisionShape = { "DynamicMeshCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__DynamicMeshCollisionShape,_wrap_new_DynamicMeshCollisionShape, swig_delete_DynamicMeshCollisionShape, swig_Mezzanine_Physics_DynamicMeshCollisionShape_methods, swig_Mezzanine_Physics_DynamicMeshCollisionShape_attributes, swig_Mezzanine_Physics_DynamicMeshCollisionShape_bases, swig_Mezzanine_Physics_DynamicMeshCollisionShape_base_names };

static int _wrap_FieldCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::FieldCollisionShape *arg1 = (Mezzanine::Physics::FieldCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::FieldCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::FieldCollisionShape::GetType",1,"Mezzanine::Physics::FieldCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape,0))){
    SWIG_fail_ptr("FieldCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::FieldCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_FieldCollisionShape_GetBulletConcaveShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::FieldCollisionShape *arg1 = (Mezzanine::Physics::FieldCollisionShape *) 0 ;
  btConcaveShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::FieldCollisionShape::GetBulletConcaveShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::FieldCollisionShape::GetBulletConcaveShape",1,"Mezzanine::Physics::FieldCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape,0))){
    SWIG_fail_ptr("FieldCollisionShape_GetBulletConcaveShape",1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape);
  }
  
  result = (btConcaveShape *)((Mezzanine::Physics::FieldCollisionShape const *)arg1)->GetBulletConcaveShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btConcaveShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_FieldCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::FieldCollisionShape *arg1 = (Mezzanine::Physics::FieldCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::FieldCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::FieldCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::FieldCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::FieldCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape,0))){
    SWIG_fail_ptr("FieldCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("FieldCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::FieldCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_FieldCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::FieldCollisionShape *arg1 = (Mezzanine::Physics::FieldCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::FieldCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::FieldCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::FieldCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::FieldCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape,0))){
    SWIG_fail_ptr("FieldCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("FieldCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_FieldCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::FieldCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::FieldCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_FieldCollisionShape(void *obj) {
Mezzanine::Physics::FieldCollisionShape *arg1 = (Mezzanine::Physics::FieldCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_FieldCollisionShape_methods[] = {
    {"GetType", _wrap_FieldCollisionShape_GetType}, 
    {"GetBulletConcaveShape", _wrap_FieldCollisionShape_GetBulletConcaveShape}, 
    {"ProtoSerialize", _wrap_FieldCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_FieldCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_FieldCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_FieldCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_FieldCollisionShape_base_names[] = {"Mezzanine::Physics::CollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_FieldCollisionShape = { "FieldCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__FieldCollisionShape,0, swig_delete_FieldCollisionShape, swig_Mezzanine_Physics_FieldCollisionShape_methods, swig_Mezzanine_Physics_FieldCollisionShape_attributes, swig_Mezzanine_Physics_FieldCollisionShape_bases, swig_Mezzanine_Physics_FieldCollisionShape_base_names };

static int _wrap_new_GearConstraint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Real arg5 ;
  Mezzanine::Physics::GearConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::GearConstraint",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GearConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GearConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GearConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GearConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GearConstraint",5,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_GearConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_GearConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_GearConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_GearConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg5 = (Mezzanine::Real const)lua_tonumber(L, 5);
  result = (Mezzanine::Physics::GearConstraint *)new Mezzanine::Physics::GearConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_SetAxisA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::SetAxisA",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::SetAxisA",1,"Mezzanine::Physics::GearConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::SetAxisA",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_SetAxisA",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("GearConstraint_SetAxisA",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAxisA((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_SetAxisB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::SetAxisB",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::SetAxisB",1,"Mezzanine::Physics::GearConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::SetAxisB",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_SetAxisB",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("GearConstraint_SetAxisB",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAxisB((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_GetAxisA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::GetAxisA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GetAxisA",1,"Mezzanine::Physics::GearConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_GetAxisA",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  result = ((Mezzanine::Physics::GearConstraint const *)arg1)->GetAxisA();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_GetAxisB(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::GetAxisB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GetAxisB",1,"Mezzanine::Physics::GearConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_GetAxisB",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  result = ((Mezzanine::Physics::GearConstraint const *)arg1)->GetAxisB();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_SetRotationRatio(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::SetRotationRatio",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::SetRotationRatio",1,"Mezzanine::Physics::GearConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::SetRotationRatio",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_SetRotationRatio",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->SetRotationRatio(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_GetRotationRatio(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::GetRotationRatio",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GetRotationRatio",1,"Mezzanine::Physics::GearConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_GetRotationRatio",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::GearConstraint const *)arg1)->GetRotationRatio();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_ValidParamOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::ValidParamOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ValidParamOnAxis",1,"Mezzanine::Physics::GearConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ValidParamOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_ValidParamOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = ((Mezzanine::Physics::GearConstraint const *)arg1)->ValidParamOnAxis(arg2);
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_ValidLinearAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::ValidLinearAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ValidLinearAxis",1,"Mezzanine::Physics::GearConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_ValidLinearAxis",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  result = ((Mezzanine::Physics::GearConstraint const *)arg1)->ValidLinearAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_ValidAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::ValidAngularAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ValidAngularAxis",1,"Mezzanine::Physics::GearConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_ValidAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  result = ((Mezzanine::Physics::GearConstraint const *)arg1)->ValidAngularAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_HasParamBeenSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::HasParamBeenSet",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::HasParamBeenSet",1,"Mezzanine::Physics::GearConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::HasParamBeenSet",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::HasParamBeenSet",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_HasParamBeenSet",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::GearConstraint const *)arg1)->HasParamBeenSet(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ProtoSerialize",1,"Mezzanine::Physics::GearConstraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("GearConstraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::GearConstraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ProtoDeSerialize",1,"Mezzanine::Physics::GearConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("GearConstraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::SerializableName",0,0)
  result = Mezzanine::Physics::GearConstraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GearConstraint_GetConstraintBase(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) 0 ;
  btTypedConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GearConstraint::GetConstraintBase",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GearConstraint::GetConstraintBase",1,"Mezzanine::Physics::GearConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint,0))){
    SWIG_fail_ptr("GearConstraint_GetConstraintBase",1,SWIGTYPE_p_Mezzanine__Physics__GearConstraint);
  }
  
  result = (btTypedConstraint *)((Mezzanine::Physics::GearConstraint const *)arg1)->GetConstraintBase();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btTypedConstraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_GearConstraint(void *obj) {
Mezzanine::Physics::GearConstraint *arg1 = (Mezzanine::Physics::GearConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_GearConstraint_methods[] = {
    {"SetAxisA", _wrap_GearConstraint_SetAxisA}, 
    {"SetAxisB", _wrap_GearConstraint_SetAxisB}, 
    {"GetAxisA", _wrap_GearConstraint_GetAxisA}, 
    {"GetAxisB", _wrap_GearConstraint_GetAxisB}, 
    {"SetRotationRatio", _wrap_GearConstraint_SetRotationRatio}, 
    {"GetRotationRatio", _wrap_GearConstraint_GetRotationRatio}, 
    {"ValidParamOnAxis", _wrap_GearConstraint_ValidParamOnAxis}, 
    {"ValidLinearAxis", _wrap_GearConstraint_ValidLinearAxis}, 
    {"ValidAngularAxis", _wrap_GearConstraint_ValidAngularAxis}, 
    {"HasParamBeenSet", _wrap_GearConstraint_HasParamBeenSet}, 
    {"ProtoSerialize", _wrap_GearConstraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_GearConstraint_ProtoDeSerialize}, 
    {"GetConstraintBase", _wrap_GearConstraint_GetConstraintBase}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_GearConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_GearConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_GearConstraint_base_names[] = {"Mezzanine::Physics::Constraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_GearConstraint = { "GearConstraint", &SWIGTYPE_p_Mezzanine__Physics__GearConstraint,_wrap_new_GearConstraint, swig_delete_GearConstraint, swig_Mezzanine_Physics_GearConstraint_methods, swig_Mezzanine_Physics_GearConstraint_attributes, swig_Mezzanine_Physics_GearConstraint_bases, swig_Mezzanine_Physics_GearConstraint_base_names };

static int _wrap_new_Generic6DofConstraint__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Boole arg7 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",6,"Mezzanine::Quaternion const &");
  if(!lua_isboolean(L,7)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",7,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg7 = (lua_toboolean(L, 7)!=0);
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",6,6)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",6,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,"Mezzanine::Transform const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_5(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Quaternion *arg3 = 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Quaternion const &");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",4,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",3,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,(Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Quaternion const &)*arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_6(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Quaternion *arg3 = 0 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",3,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,(Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Quaternion const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_7(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  Mezzanine::Boole arg3 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Transform const &");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",3,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg3 = (lua_toboolean(L, 3)!=0);
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,(Mezzanine::Transform const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint__SWIG_8(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  Mezzanine::Physics::Generic6DofConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofConstraint",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Physics::Generic6DofConstraint *)new Mezzanine::Physics::Generic6DofConstraint(arg1,(Mezzanine::Transform const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofConstraint(lua_State* L) {
  int argc;
  int argv[8]={
    1,2,3,4,5,6,7,8
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_Generic6DofConstraint__SWIG_8(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isboolean(L,argv[2]);
        }
        if (_v) {
          return _wrap_new_Generic6DofConstraint__SWIG_7(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_Generic6DofConstraint__SWIG_6(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_Generic6DofConstraint__SWIG_5(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_Generic6DofConstraint__SWIG_4(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_Generic6DofConstraint__SWIG_3(L);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                return _wrap_new_Generic6DofConstraint__SWIG_2(L);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                {
                  _v = lua_isboolean(L,argv[6]);
                }
                if (_v) {
                  return _wrap_new_Generic6DofConstraint__SWIG_1(L);
                }
              }
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Generic6DofConstraint'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::Generic6DofConstraint::Generic6DofConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Generic6DofConstraint_SetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetPivotATransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotATransform",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotATransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotATransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotATransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetPivotBTransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotBTransform",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotBTransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotBTransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotBTransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetPivotATransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetPivotATransform",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetPivotATransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetPivotBTransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetPivotBTransform",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetPivotBTransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetPivotALocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotALocation",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotALocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotALocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotALocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetPivotBLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotBLocation",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotBLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotBLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotBLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetPivotALocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetPivotALocation",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetPivotALocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetPivotBLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetPivotBLocation",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetPivotBLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetPivotARotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetPivotARotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotARotation",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotARotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotARotation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotARotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetPivotARotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetPivotBRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetPivotBRotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotBRotation",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetPivotBRotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotBRotation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetPivotBRotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetPivotBRotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetPivotARotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetPivotARotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetPivotARotation",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetPivotARotation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetPivotARotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetPivotBRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetPivotBRotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetPivotBRotation",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetPivotBRotation",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetPivotBRotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLimit",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLimit",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLimit",2,"int");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLimit",3,"Mezzanine::Real");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLimit",4,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLimit",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real)lua_tonumber(L, 4);
  (arg1)->SetLimit(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearLimitUpper(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitUpper",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitUpper",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitUpper",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitUpper",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitUpper",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearLimitUpper((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearLimitLower(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitLower",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitLower",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitLower",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitLower",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitLower",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearLimitLower((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearLimitUpper(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitUpper",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitUpper",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearLimitUpper",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearLimitUpper();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearLimitLower(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitLower",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitLower",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearLimitLower",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearLimitLower();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularLimitUpper(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitUpper",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitUpper",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitUpper",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitUpper",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitUpper",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularLimitUpper((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularLimitLower(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitLower",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitLower",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitLower",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitLower",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitLower",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularLimitLower((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularLimitUpper(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitUpper",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitUpper",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularLimitUpper",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularLimitUpper();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularLimitLower(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitLower",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitLower",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularLimitLower",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularLimitLower();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularLimitLowerOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitLowerOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitLowerOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitLowerOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularLimitLowerOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularLimitLowerOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularLimitUpperOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitUpperOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitUpperOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitUpperOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularLimitUpperOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularLimitUpperOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_AxisToAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  int result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::AxisToAngularAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::AxisToAngularAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::AxisToAngularAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_AxisToAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (int)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->AxisToAngularAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularLimitMaxForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForce",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForce",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForce",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitMaxForce",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitMaxForce",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularLimitMaxForce((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularLimitMaxForceOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForceOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForceOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForceOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularLimitMaxForceOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularLimitMaxForceOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetAngularLimitMaxForceOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularLimitMaxForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitMaxForce",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitMaxForce",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularLimitMaxForce",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularLimitMaxForce();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularLimitMaxForceOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitMaxForceOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitMaxForceOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularLimitMaxForceOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularLimitMaxForceOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularLimitMaxForceOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorTargetVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocity",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorTargetVelocity",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorTargetVelocity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularMotorTargetVelocity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorTargetVelocityOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocityOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocityOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocityOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorTargetVelocityOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorTargetVelocityOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetAngularMotorTargetVelocityOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorTargetVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorTargetVelocity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorTargetVelocity",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorTargetVelocity",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorTargetVelocity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorTargetVelocityOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorTargetVelocityOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorTargetVelocityOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorTargetVelocityOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorTargetVelocityOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorTargetVelocityOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorMaxForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForce",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForce",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForce",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorMaxForce",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorMaxForce",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularMotorMaxForce((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorMaxForceOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForceOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForceOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForceOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorMaxForceOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorMaxForceOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetAngularMotorMaxForceOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorMaxForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorMaxForce",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorMaxForce",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorMaxForce",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorMaxForce();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorMaxForceOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorMaxForceOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorMaxForceOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorMaxForceOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorMaxForceOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorMaxForceOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDamping",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDamping",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorDamping",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularMotorDamping((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorDampingOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDampingOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDampingOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDampingOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorDampingOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorDampingOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetAngularMotorDampingOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorDamping",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorDamping();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorDampingOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorDampingOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorDampingOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorDampingOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorDampingOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorDampingOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorRestitution(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitution",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitution",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitution",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorRestitution",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorRestitution",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularMotorRestitution((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorRestitutionOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitutionOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitutionOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitutionOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorRestitutionOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorRestitutionOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetAngularMotorRestitutionOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorRestitution(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorRestitution",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorRestitution",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorRestitution",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorRestitution();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorRestitutionOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorRestitutionOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorRestitutionOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorRestitutionOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorRestitutionOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorRestitutionOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabled",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabled",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabled",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorEnabled",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularMotorEnabled((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetAngularMotorEnabledOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabledOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabledOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabledOnAxis",2,"Mezzanine::Boole");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetAngularMotorEnabledOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetAngularMotorEnabledOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetAngularMotorEnabledOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorEnabled",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorEnabled",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorEnabled();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetAngularMotorEnabledOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorEnabledOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorEnabledOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetAngularMotorEnabledOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetAngularMotorEnabledOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetAngularMotorEnabledOnAxis(arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearLimitSoftness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitSoftness",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitSoftness",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitSoftness",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitSoftness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetLinearLimitSoftness(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearLimitSoftness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitSoftness",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitSoftness",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearLimitSoftness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearLimitSoftness();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearLimitDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitDamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitDamping",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitDamping",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetLinearLimitDamping(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearLimitDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitDamping",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearLimitDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearLimitDamping();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearLimitRestitution(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitRestitution",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitRestitution",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearLimitRestitution",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearLimitRestitution",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetLinearLimitRestitution(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearLimitRestitution(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitRestitution",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearLimitRestitution",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearLimitRestitution",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearLimitRestitution();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearMotorMaxForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForce",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForce",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForce",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorMaxForce",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorMaxForce",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearMotorMaxForce((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearMotorMaxForceOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForceOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForceOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForceOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorMaxForceOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorMaxForceOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetLinearMotorMaxForceOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearMotorMaxForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorMaxForce",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorMaxForce",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearMotorMaxForce",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearMotorMaxForce();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearMotorMaxForceOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorMaxForceOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorMaxForceOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorMaxForceOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearMotorMaxForceOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearMotorMaxForceOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearMotorTargetVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocity",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorTargetVelocity",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorTargetVelocity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearMotorTargetVelocity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearMotorTargetVelocityOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocityOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocityOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocityOnAxis",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorTargetVelocityOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorTargetVelocityOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetLinearMotorTargetVelocityOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearMotorTargetVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorTargetVelocity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorTargetVelocity",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearMotorTargetVelocity",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearMotorTargetVelocity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearMotorTargetVelocityOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorTargetVelocityOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorTargetVelocityOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorTargetVelocityOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearMotorTargetVelocityOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearMotorTargetVelocityOnAxis(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearMotorEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabled",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabled",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabled",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorEnabled",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearMotorEnabled((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetLinearMotorEnabledOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  int arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabledOnAxis",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabledOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabledOnAxis",2,"Mezzanine::Boole");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetLinearMotorEnabledOnAxis",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetLinearMotorEnabledOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  arg3 = (int)lua_tonumber(L, 3);
  (arg1)->SetLinearMotorEnabledOnAxis(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearMotorEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorEnabled",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorEnabled",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearMotorEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearMotorEnabled();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetLinearMotorEnabledOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorEnabledOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorEnabledOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetLinearMotorEnabledOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetLinearMotorEnabledOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetLinearMotorEnabledOnAxis(arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_ValidParamOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::ValidParamOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ValidParamOnAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ValidParamOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ValidParamOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->ValidParamOnAxis(arg2);
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_ValidLinearAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::ValidLinearAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ValidLinearAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ValidLinearAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->ValidLinearAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_ValidAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::ValidAngularAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ValidAngularAxis",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ValidAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->ValidAngularAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_HasParamBeenSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::HasParamBeenSet",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::HasParamBeenSet",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::HasParamBeenSet",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::HasParamBeenSet",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_HasParamBeenSet",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->HasParamBeenSet(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetUseFrameOffset(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetUseFrameOffset",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetUseFrameOffset",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetUseFrameOffset",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetUseFrameOffset();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SetUseFrameOffset(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SetUseFrameOffset",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetUseFrameOffset",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::SetUseFrameOffset",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_SetUseFrameOffset",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetUseFrameOffset(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_GetConstraintBase(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  btTypedConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::GetConstraintBase",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::GetConstraintBase",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_GetConstraintBase",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  result = (btTypedConstraint *)((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->GetConstraintBase();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btTypedConstraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ProtoSerialize",1,"Mezzanine::Physics::Generic6DofConstraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::Generic6DofConstraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ProtoDeSerialize",1,"Mezzanine::Physics::Generic6DofConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofConstraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Generic6DofConstraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofConstraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofConstraint::SerializableName",0,0)
  result = Mezzanine::Physics::Generic6DofConstraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Generic6DofConstraint(void *obj) {
Mezzanine::Physics::Generic6DofConstraint *arg1 = (Mezzanine::Physics::Generic6DofConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_Generic6DofConstraint_methods[] = {
    {"SetPivotATransform", _wrap_Generic6DofConstraint_SetPivotATransform}, 
    {"SetPivotBTransform", _wrap_Generic6DofConstraint_SetPivotBTransform}, 
    {"GetPivotATransform", _wrap_Generic6DofConstraint_GetPivotATransform}, 
    {"GetPivotBTransform", _wrap_Generic6DofConstraint_GetPivotBTransform}, 
    {"SetPivotALocation", _wrap_Generic6DofConstraint_SetPivotALocation}, 
    {"SetPivotBLocation", _wrap_Generic6DofConstraint_SetPivotBLocation}, 
    {"GetPivotALocation", _wrap_Generic6DofConstraint_GetPivotALocation}, 
    {"GetPivotBLocation", _wrap_Generic6DofConstraint_GetPivotBLocation}, 
    {"SetPivotARotation", _wrap_Generic6DofConstraint_SetPivotARotation}, 
    {"SetPivotBRotation", _wrap_Generic6DofConstraint_SetPivotBRotation}, 
    {"GetPivotARotation", _wrap_Generic6DofConstraint_GetPivotARotation}, 
    {"GetPivotBRotation", _wrap_Generic6DofConstraint_GetPivotBRotation}, 
    {"SetLimit", _wrap_Generic6DofConstraint_SetLimit}, 
    {"SetLinearLimitUpper", _wrap_Generic6DofConstraint_SetLinearLimitUpper}, 
    {"SetLinearLimitLower", _wrap_Generic6DofConstraint_SetLinearLimitLower}, 
    {"GetLinearLimitUpper", _wrap_Generic6DofConstraint_GetLinearLimitUpper}, 
    {"GetLinearLimitLower", _wrap_Generic6DofConstraint_GetLinearLimitLower}, 
    {"SetAngularLimitUpper", _wrap_Generic6DofConstraint_SetAngularLimitUpper}, 
    {"SetAngularLimitLower", _wrap_Generic6DofConstraint_SetAngularLimitLower}, 
    {"GetAngularLimitUpper", _wrap_Generic6DofConstraint_GetAngularLimitUpper}, 
    {"GetAngularLimitLower", _wrap_Generic6DofConstraint_GetAngularLimitLower}, 
    {"GetAngularLimitLowerOnAxis", _wrap_Generic6DofConstraint_GetAngularLimitLowerOnAxis}, 
    {"GetAngularLimitUpperOnAxis", _wrap_Generic6DofConstraint_GetAngularLimitUpperOnAxis}, 
    {"AxisToAngularAxis", _wrap_Generic6DofConstraint_AxisToAngularAxis}, 
    {"SetAngularLimitMaxForce", _wrap_Generic6DofConstraint_SetAngularLimitMaxForce}, 
    {"SetAngularLimitMaxForceOnAxis", _wrap_Generic6DofConstraint_SetAngularLimitMaxForceOnAxis}, 
    {"GetAngularLimitMaxForce", _wrap_Generic6DofConstraint_GetAngularLimitMaxForce}, 
    {"GetAngularLimitMaxForceOnAxis", _wrap_Generic6DofConstraint_GetAngularLimitMaxForceOnAxis}, 
    {"SetAngularMotorTargetVelocity", _wrap_Generic6DofConstraint_SetAngularMotorTargetVelocity}, 
    {"SetAngularMotorTargetVelocityOnAxis", _wrap_Generic6DofConstraint_SetAngularMotorTargetVelocityOnAxis}, 
    {"GetAngularMotorTargetVelocity", _wrap_Generic6DofConstraint_GetAngularMotorTargetVelocity}, 
    {"GetAngularMotorTargetVelocityOnAxis", _wrap_Generic6DofConstraint_GetAngularMotorTargetVelocityOnAxis}, 
    {"SetAngularMotorMaxForce", _wrap_Generic6DofConstraint_SetAngularMotorMaxForce}, 
    {"SetAngularMotorMaxForceOnAxis", _wrap_Generic6DofConstraint_SetAngularMotorMaxForceOnAxis}, 
    {"GetAngularMotorMaxForce", _wrap_Generic6DofConstraint_GetAngularMotorMaxForce}, 
    {"GetAngularMotorMaxForceOnAxis", _wrap_Generic6DofConstraint_GetAngularMotorMaxForceOnAxis}, 
    {"SetAngularMotorDamping", _wrap_Generic6DofConstraint_SetAngularMotorDamping}, 
    {"SetAngularMotorDampingOnAxis", _wrap_Generic6DofConstraint_SetAngularMotorDampingOnAxis}, 
    {"GetAngularMotorDamping", _wrap_Generic6DofConstraint_GetAngularMotorDamping}, 
    {"GetAngularMotorDampingOnAxis", _wrap_Generic6DofConstraint_GetAngularMotorDampingOnAxis}, 
    {"SetAngularMotorRestitution", _wrap_Generic6DofConstraint_SetAngularMotorRestitution}, 
    {"SetAngularMotorRestitutionOnAxis", _wrap_Generic6DofConstraint_SetAngularMotorRestitutionOnAxis}, 
    {"GetAngularMotorRestitution", _wrap_Generic6DofConstraint_GetAngularMotorRestitution}, 
    {"GetAngularMotorRestitutionOnAxis", _wrap_Generic6DofConstraint_GetAngularMotorRestitutionOnAxis}, 
    {"SetAngularMotorEnabled", _wrap_Generic6DofConstraint_SetAngularMotorEnabled}, 
    {"SetAngularMotorEnabledOnAxis", _wrap_Generic6DofConstraint_SetAngularMotorEnabledOnAxis}, 
    {"GetAngularMotorEnabled", _wrap_Generic6DofConstraint_GetAngularMotorEnabled}, 
    {"GetAngularMotorEnabledOnAxis", _wrap_Generic6DofConstraint_GetAngularMotorEnabledOnAxis}, 
    {"SetLinearLimitSoftness", _wrap_Generic6DofConstraint_SetLinearLimitSoftness}, 
    {"GetLinearLimitSoftness", _wrap_Generic6DofConstraint_GetLinearLimitSoftness}, 
    {"SetLinearLimitDamping", _wrap_Generic6DofConstraint_SetLinearLimitDamping}, 
    {"GetLinearLimitDamping", _wrap_Generic6DofConstraint_GetLinearLimitDamping}, 
    {"SetLinearLimitRestitution", _wrap_Generic6DofConstraint_SetLinearLimitRestitution}, 
    {"GetLinearLimitRestitution", _wrap_Generic6DofConstraint_GetLinearLimitRestitution}, 
    {"SetLinearMotorMaxForce", _wrap_Generic6DofConstraint_SetLinearMotorMaxForce}, 
    {"SetLinearMotorMaxForceOnAxis", _wrap_Generic6DofConstraint_SetLinearMotorMaxForceOnAxis}, 
    {"GetLinearMotorMaxForce", _wrap_Generic6DofConstraint_GetLinearMotorMaxForce}, 
    {"GetLinearMotorMaxForceOnAxis", _wrap_Generic6DofConstraint_GetLinearMotorMaxForceOnAxis}, 
    {"SetLinearMotorTargetVelocity", _wrap_Generic6DofConstraint_SetLinearMotorTargetVelocity}, 
    {"SetLinearMotorTargetVelocityOnAxis", _wrap_Generic6DofConstraint_SetLinearMotorTargetVelocityOnAxis}, 
    {"GetLinearMotorTargetVelocity", _wrap_Generic6DofConstraint_GetLinearMotorTargetVelocity}, 
    {"GetLinearMotorTargetVelocityOnAxis", _wrap_Generic6DofConstraint_GetLinearMotorTargetVelocityOnAxis}, 
    {"SetLinearMotorEnabled", _wrap_Generic6DofConstraint_SetLinearMotorEnabled}, 
    {"SetLinearMotorEnabledOnAxis", _wrap_Generic6DofConstraint_SetLinearMotorEnabledOnAxis}, 
    {"GetLinearMotorEnabled", _wrap_Generic6DofConstraint_GetLinearMotorEnabled}, 
    {"GetLinearMotorEnabledOnAxis", _wrap_Generic6DofConstraint_GetLinearMotorEnabledOnAxis}, 
    {"ValidParamOnAxis", _wrap_Generic6DofConstraint_ValidParamOnAxis}, 
    {"ValidLinearAxis", _wrap_Generic6DofConstraint_ValidLinearAxis}, 
    {"ValidAngularAxis", _wrap_Generic6DofConstraint_ValidAngularAxis}, 
    {"HasParamBeenSet", _wrap_Generic6DofConstraint_HasParamBeenSet}, 
    {"GetUseFrameOffset", _wrap_Generic6DofConstraint_GetUseFrameOffset}, 
    {"SetUseFrameOffset", _wrap_Generic6DofConstraint_SetUseFrameOffset}, 
    {"GetConstraintBase", _wrap_Generic6DofConstraint_GetConstraintBase}, 
    {"ProtoSerialize", _wrap_Generic6DofConstraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Generic6DofConstraint_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_Generic6DofConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_Generic6DofConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_Generic6DofConstraint_base_names[] = {"Mezzanine::Physics::DualTransformConstraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_Generic6DofConstraint = { "Generic6DofConstraint", &SWIGTYPE_p_Mezzanine__Physics__Generic6DofConstraint,_wrap_new_Generic6DofConstraint, swig_delete_Generic6DofConstraint, swig_Mezzanine_Physics_Generic6DofConstraint_methods, swig_Mezzanine_Physics_Generic6DofConstraint_attributes, swig_Mezzanine_Physics_Generic6DofConstraint_bases, swig_Mezzanine_Physics_Generic6DofConstraint_base_names };

static int _wrap_new_Generic6DofSpringConstraint__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Boole arg7 ;
  Mezzanine::Physics::Generic6DofSpringConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",6,"Mezzanine::Quaternion const &");
  if(!lua_isboolean(L,7)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",7,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg7 = (lua_toboolean(L, 7)!=0);
  result = (Mezzanine::Physics::Generic6DofSpringConstraint *)new Mezzanine::Physics::Generic6DofSpringConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofSpringConstraint__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Physics::Generic6DofSpringConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",6,6)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",6,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Physics::Generic6DofSpringConstraint *)new Mezzanine::Physics::Generic6DofSpringConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofSpringConstraint__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::Physics::Generic6DofSpringConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",4,"Mezzanine::Transform const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::Generic6DofSpringConstraint *)new Mezzanine::Physics::Generic6DofSpringConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofSpringConstraint__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Physics::Generic6DofSpringConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint",4,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_Generic6DofSpringConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Physics::Generic6DofSpringConstraint *)new Mezzanine::Physics::Generic6DofSpringConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Generic6DofSpringConstraint(lua_State* L) {
  int argc;
  int argv[8]={
    1,2,3,4,5,6,7,8
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_Generic6DofSpringConstraint__SWIG_4(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_Generic6DofSpringConstraint__SWIG_3(L);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                return _wrap_new_Generic6DofSpringConstraint__SWIG_2(L);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                {
                  _v = lua_isboolean(L,argv[6]);
                }
                if (_v) {
                  return _wrap_new_Generic6DofSpringConstraint__SWIG_1(L);
                }
              }
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Generic6DofSpringConstraint'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::Generic6DofSpringConstraint::Generic6DofSpringConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringLinearStiffness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearStiffness",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearStiffness",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearStiffness",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringLinearStiffness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringLinearStiffness",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetSpringLinearStiffness((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringLinearDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearDamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearDamping",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearDamping",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringLinearDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringLinearDamping",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetSpringLinearDamping((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringLinearEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearEnabled",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearEnabled",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringLinearEnabled",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringLinearEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringLinearEnabled",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetSpringLinearEnabled((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringLinearStiffness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringLinearStiffness",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringLinearStiffness",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringLinearStiffness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringLinearStiffness();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringLinearDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringLinearDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringLinearDamping",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringLinearDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringLinearDamping();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringLinearEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringLinearEnabled",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringLinearEnabled",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringLinearEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringLinearEnabled();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringAngularStiffness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularStiffness",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularStiffness",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularStiffness",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringAngularStiffness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringAngularStiffness",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetSpringAngularStiffness((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringAngularDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularDamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularDamping",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularDamping",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringAngularDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringAngularDamping",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetSpringAngularDamping((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringAngularEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularEnabled",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularEnabled",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringAngularEnabled",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringAngularEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringAngularEnabled",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetSpringAngularEnabled((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringAngularStiffness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringAngularStiffness",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringAngularStiffness",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringAngularStiffness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringAngularStiffness();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringAngularDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringAngularDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringAngularDamping",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringAngularDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringAngularDamping();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringAngularEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringAngularEnabled",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringAngularEnabled",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringAngularEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  result = ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringAngularEnabled();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringStiffness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringStiffness",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringStiffness",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringStiffness",2,"int");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringStiffness",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringStiffness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetSpringStiffness(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringDamping",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringDamping",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringDamping",2,"int");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringDamping",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetSpringDamping(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SetSpringEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Boole arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringEnabled",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringEnabled",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringEnabled",2,"int");
  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::SetSpringEnabled",3,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_SetSpringEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  arg3 = (lua_toboolean(L, 3)!=0);
  (arg1)->SetSpringEnabled(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringStiffness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringStiffness",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringStiffness",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringStiffness",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringStiffness",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringStiffness(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringDamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringDamping",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringDamping",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringDamping",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Real)((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringDamping(arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_GetSpringEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  int arg2 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringEnabled",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringEnabled",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::GetSpringEnabled",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_GetSpringEnabled",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->GetSpringEnabled(arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::ProtoSerialize",1,"Mezzanine::Physics::Generic6DofSpringConstraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::Generic6DofSpringConstraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::ProtoDeSerialize",1,"Mezzanine::Physics::Generic6DofSpringConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Generic6DofSpringConstraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Generic6DofSpringConstraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Generic6DofSpringConstraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::Generic6DofSpringConstraint::SerializableName",0,0)
  result = Mezzanine::Physics::Generic6DofSpringConstraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Generic6DofSpringConstraint(void *obj) {
Mezzanine::Physics::Generic6DofSpringConstraint *arg1 = (Mezzanine::Physics::Generic6DofSpringConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_Generic6DofSpringConstraint_methods[] = {
    {"SetSpringLinearStiffness", _wrap_Generic6DofSpringConstraint_SetSpringLinearStiffness}, 
    {"SetSpringLinearDamping", _wrap_Generic6DofSpringConstraint_SetSpringLinearDamping}, 
    {"SetSpringLinearEnabled", _wrap_Generic6DofSpringConstraint_SetSpringLinearEnabled}, 
    {"GetSpringLinearStiffness", _wrap_Generic6DofSpringConstraint_GetSpringLinearStiffness}, 
    {"GetSpringLinearDamping", _wrap_Generic6DofSpringConstraint_GetSpringLinearDamping}, 
    {"GetSpringLinearEnabled", _wrap_Generic6DofSpringConstraint_GetSpringLinearEnabled}, 
    {"SetSpringAngularStiffness", _wrap_Generic6DofSpringConstraint_SetSpringAngularStiffness}, 
    {"SetSpringAngularDamping", _wrap_Generic6DofSpringConstraint_SetSpringAngularDamping}, 
    {"SetSpringAngularEnabled", _wrap_Generic6DofSpringConstraint_SetSpringAngularEnabled}, 
    {"GetSpringAngularStiffness", _wrap_Generic6DofSpringConstraint_GetSpringAngularStiffness}, 
    {"GetSpringAngularDamping", _wrap_Generic6DofSpringConstraint_GetSpringAngularDamping}, 
    {"GetSpringAngularEnabled", _wrap_Generic6DofSpringConstraint_GetSpringAngularEnabled}, 
    {"SetSpringStiffness", _wrap_Generic6DofSpringConstraint_SetSpringStiffness}, 
    {"SetSpringDamping", _wrap_Generic6DofSpringConstraint_SetSpringDamping}, 
    {"SetSpringEnabled", _wrap_Generic6DofSpringConstraint_SetSpringEnabled}, 
    {"GetSpringStiffness", _wrap_Generic6DofSpringConstraint_GetSpringStiffness}, 
    {"GetSpringDamping", _wrap_Generic6DofSpringConstraint_GetSpringDamping}, 
    {"GetSpringEnabled", _wrap_Generic6DofSpringConstraint_GetSpringEnabled}, 
    {"ProtoSerialize", _wrap_Generic6DofSpringConstraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Generic6DofSpringConstraint_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_Generic6DofSpringConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_Generic6DofSpringConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_Generic6DofSpringConstraint_base_names[] = {"Mezzanine::Physics::Generic6DofConstraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_Generic6DofSpringConstraint = { "Generic6DofSpringConstraint", &SWIGTYPE_p_Mezzanine__Physics__Generic6DofSpringConstraint,_wrap_new_Generic6DofSpringConstraint, swig_delete_Generic6DofSpringConstraint, swig_Mezzanine_Physics_Generic6DofSpringConstraint_methods, swig_Mezzanine_Physics_Generic6DofSpringConstraint_attributes, swig_Mezzanine_Physics_Generic6DofSpringConstraint_bases, swig_Mezzanine_Physics_Generic6DofSpringConstraint_base_names };

static int _wrap_new_GhostProxy__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PhysicsManager *arg1 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GhostProxy",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GhostProxy",1,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_GhostProxy",1,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::GhostProxy *)new Mezzanine::Physics::GhostProxy(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_GhostProxy__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::CollisionShape *arg1 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::PhysicsManager *arg2 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GhostProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GhostProxy",1,"Mezzanine::Physics::CollisionShape *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GhostProxy",2,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("new_GhostProxy",1,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_GhostProxy",2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::GhostProxy *)new Mezzanine::Physics::GhostProxy(arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_GhostProxy__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Physics::PhysicsManager *arg2 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::GhostProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GhostProxy",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GhostProxy",1,"XML::Node const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GhostProxy",2,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_GhostProxy",1,SWIGTYPE_p_XML__Node);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_GhostProxy",2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::GhostProxy *)new Mezzanine::Physics::GhostProxy((XML::Node const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_GhostProxy(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_GhostProxy__SWIG_0(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_GhostProxy__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_GhostProxy__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_GhostProxy'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::GhostProxy::GhostProxy(Mezzanine::Physics::PhysicsManager *)\n"
    "    Mezzanine::Physics::GhostProxy::GhostProxy(Mezzanine::Physics::CollisionShape *,Mezzanine::Physics::PhysicsManager *)\n"
    "    Mezzanine::Physics::GhostProxy::GhostProxy(XML::Node const &,Mezzanine::Physics::PhysicsManager *)\n");
  lua_error(L);return 0;
}


static int _wrap_GhostProxy_GetProxyType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  Mezzanine::ProxyType result;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetProxyType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetProxyType",1,"Mezzanine::Physics::GhostProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_GetProxyType",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  result = (Mezzanine::ProxyType)((Mezzanine::Physics::GhostProxy const *)arg1)->GetProxyType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_AddToWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::AddToWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::AddToWorld",1,"Mezzanine::Physics::GhostProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_AddToWorld",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  (arg1)->AddToWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_RemoveFromWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::RemoveFromWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::RemoveFromWorld",1,"Mezzanine::Physics::GhostProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_RemoveFromWorld",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  (arg1)->RemoveFromWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_GetAABBOverlappingProxy(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  Mezzanine::UInt32 arg2 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetAABBOverlappingProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetAABBOverlappingProxy",1,"Mezzanine::Physics::GhostProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetAABBOverlappingProxy",2,"Mezzanine::UInt32 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_GetAABBOverlappingProxy",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::UInt32 const)lua_tonumber(L, 2);
  result = (Mezzanine::Physics::CollidableProxy *)(arg1)->GetAABBOverlappingProxy(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_GetNumAABBOverlappingProxies(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  Mezzanine::UInt32 result;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetNumAABBOverlappingProxies",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetNumAABBOverlappingProxies",1,"Mezzanine::Physics::GhostProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_GetNumAABBOverlappingProxies",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  result = (Mezzanine::UInt32)((Mezzanine::Physics::GhostProxy const *)arg1)->GetNumAABBOverlappingProxies();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_GetShapeOverlappingProxy(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  Mezzanine::UInt32 arg2 ;
  Mezzanine::Physics::CollidableProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetShapeOverlappingProxy",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetShapeOverlappingProxy",1,"Mezzanine::Physics::GhostProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetShapeOverlappingProxy",2,"Mezzanine::UInt32 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_GetShapeOverlappingProxy",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::UInt32 const)lua_tonumber(L, 2);
  result = (Mezzanine::Physics::CollidableProxy *)(arg1)->GetShapeOverlappingProxy(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__CollidableProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_GetNumShapeOverlappingProxies(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  Mezzanine::UInt32 result;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetNumShapeOverlappingProxies",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetNumShapeOverlappingProxies",1,"Mezzanine::Physics::GhostProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_GetNumShapeOverlappingProxies",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  result = (Mezzanine::UInt32)((Mezzanine::Physics::GhostProxy const *)arg1)->GetNumShapeOverlappingProxies();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_ProtoSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::ProtoSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::ProtoSerializeProperties",1,"Mezzanine::Physics::GhostProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::ProtoSerializeProperties",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_ProtoSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("GhostProxy_ProtoSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::GhostProxy const *)arg1)->ProtoSerializeProperties(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_ProtoDeSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::ProtoDeSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::ProtoDeSerializeProperties",1,"Mezzanine::Physics::GhostProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::ProtoDeSerializeProperties",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_ProtoDeSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("GhostProxy_ProtoDeSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerializeProperties((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_GetDerivedSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetDerivedSerializableName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::GetDerivedSerializableName",1,"Mezzanine::Physics::GhostProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy_GetDerivedSerializableName",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  result = ((Mezzanine::Physics::GhostProxy const *)arg1)->GetDerivedSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy_GetSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::GetSerializableName",0,0)
  result = Mezzanine::Physics::GhostProxy::GetSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy__GetPhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  btPairCachingGhostObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::_GetPhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::_GetPhysicsObject",1,"Mezzanine::Physics::GhostProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy__GetPhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  result = (btPairCachingGhostObject *)((Mezzanine::Physics::GhostProxy const *)arg1)->_GetPhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btPairCachingGhostObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_GhostProxy__GetBasePhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) 0 ;
  btCollisionObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::GhostProxy::_GetBasePhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::GhostProxy::_GetBasePhysicsObject",1,"Mezzanine::Physics::GhostProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy,0))){
    SWIG_fail_ptr("GhostProxy__GetBasePhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__GhostProxy);
  }
  
  result = (btCollisionObject *)((Mezzanine::Physics::GhostProxy const *)arg1)->_GetBasePhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCollisionObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_GhostProxy(void *obj) {
Mezzanine::Physics::GhostProxy *arg1 = (Mezzanine::Physics::GhostProxy *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_GhostProxy_methods[] = {
    {"GetProxyType", _wrap_GhostProxy_GetProxyType}, 
    {"AddToWorld", _wrap_GhostProxy_AddToWorld}, 
    {"RemoveFromWorld", _wrap_GhostProxy_RemoveFromWorld}, 
    {"GetAABBOverlappingProxy", _wrap_GhostProxy_GetAABBOverlappingProxy}, 
    {"GetNumAABBOverlappingProxies", _wrap_GhostProxy_GetNumAABBOverlappingProxies}, 
    {"GetShapeOverlappingProxy", _wrap_GhostProxy_GetShapeOverlappingProxy}, 
    {"GetNumShapeOverlappingProxies", _wrap_GhostProxy_GetNumShapeOverlappingProxies}, 
    {"ProtoSerializeProperties", _wrap_GhostProxy_ProtoSerializeProperties}, 
    {"ProtoDeSerializeProperties", _wrap_GhostProxy_ProtoDeSerializeProperties}, 
    {"GetDerivedSerializableName", _wrap_GhostProxy_GetDerivedSerializableName}, 
    {"_GetPhysicsObject", _wrap_GhostProxy__GetPhysicsObject}, 
    {"_GetBasePhysicsObject", _wrap_GhostProxy__GetBasePhysicsObject}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_GhostProxy_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_GhostProxy_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_GhostProxy_base_names[] = {"Mezzanine::Physics::CollidableProxy *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_GhostProxy = { "GhostProxy", &SWIGTYPE_p_Mezzanine__Physics__GhostProxy,_wrap_new_GhostProxy, swig_delete_GhostProxy, swig_Mezzanine_Physics_GhostProxy_methods, swig_Mezzanine_Physics_GhostProxy_attributes, swig_Mezzanine_Physics_GhostProxy_bases, swig_Mezzanine_Physics_GhostProxy_base_names };

static int _wrap_new_HeightfieldCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::HeightfieldCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape",1,1)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape",1,"Mezzanine::String const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  result = (Mezzanine::Physics::HeightfieldCollisionShape *)new Mezzanine::Physics::HeightfieldCollisionShape((Mezzanine::String const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HeightfieldCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HeightfieldCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btHeightfieldTerrainShape *arg2 = (btHeightfieldTerrainShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::HeightfieldCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape",2,"btHeightfieldTerrainShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btHeightfieldTerrainShape,0))){
    SWIG_fail_ptr("new_HeightfieldCollisionShape",2,SWIGTYPE_p_btHeightfieldTerrainShape);
  }
  
  result = (Mezzanine::Physics::HeightfieldCollisionShape *)new Mezzanine::Physics::HeightfieldCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HeightfieldCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HeightfieldCollisionShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      return _wrap_new_HeightfieldCollisionShape__SWIG_0(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btHeightfieldTerrainShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_HeightfieldCollisionShape__SWIG_1(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_HeightfieldCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape(Mezzanine::String const &)\n"
    "    Mezzanine::Physics::HeightfieldCollisionShape::HeightfieldCollisionShape(Mezzanine::String const &,btHeightfieldTerrainShape *)\n");
  lua_error(L);return 0;
}


static int _wrap_HeightfieldCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HeightfieldCollisionShape *arg1 = (Mezzanine::Physics::HeightfieldCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::HeightfieldCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HeightfieldCollisionShape::GetType",1,"Mezzanine::Physics::HeightfieldCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HeightfieldCollisionShape,0))){
    SWIG_fail_ptr("HeightfieldCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__HeightfieldCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::HeightfieldCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_HeightfieldCollisionShape(void *obj) {
Mezzanine::Physics::HeightfieldCollisionShape *arg1 = (Mezzanine::Physics::HeightfieldCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_HeightfieldCollisionShape_methods[] = {
    {"GetType", _wrap_HeightfieldCollisionShape_GetType}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_HeightfieldCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_HeightfieldCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_HeightfieldCollisionShape_base_names[] = {"Mezzanine::Physics::FieldCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_HeightfieldCollisionShape = { "HeightfieldCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__HeightfieldCollisionShape,_wrap_new_HeightfieldCollisionShape, swig_delete_HeightfieldCollisionShape, swig_Mezzanine_Physics_HeightfieldCollisionShape_methods, swig_Mezzanine_Physics_HeightfieldCollisionShape_attributes, swig_Mezzanine_Physics_HeightfieldCollisionShape_bases, swig_Mezzanine_Physics_HeightfieldCollisionShape_base_names };

static int _wrap_new_HingeConstraint__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Physics::Vector3 *arg5 = 0 ;
  Mezzanine::Physics::Vector3 *arg6 = 0 ;
  Mezzanine::Boole arg7 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",5,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",6,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isboolean(L,7)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",7,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",5,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",6,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg7 = (lua_toboolean(L, 7)!=0);
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Physics::Vector3 const &)*arg5,(Mezzanine::Physics::Vector3 const &)*arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Physics::Vector3 *arg5 = 0 ;
  Mezzanine::Physics::Vector3 *arg6 = 0 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",6,6)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",5,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",6,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",5,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",6,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Physics::Vector3 const &)*arg5,(Mezzanine::Physics::Vector3 const &)*arg6);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,(Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Physics::Vector3 const &)*arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,(Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Physics::Vector3 const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Boole arg7 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",6,"Mezzanine::Quaternion const &");
  if(!lua_isboolean(L,7)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",7,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_HingeConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_HingeConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg7 = (lua_toboolean(L, 7)!=0);
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_5(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",6,6)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",6,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_HingeConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_HingeConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_HingeConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_6(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Transform const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_HingeConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint__SWIG_7(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Physics::HingeConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HingeConstraint",4,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_HingeConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_HingeConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_HingeConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Physics::HingeConstraint *)new Mezzanine::Physics::HingeConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_HingeConstraint(lua_State* L) {
  int argc;
  int argv[8]={
    1,2,3,4,5,6,7,8
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_HingeConstraint__SWIG_3(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_HingeConstraint__SWIG_2(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_HingeConstraint__SWIG_7(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_HingeConstraint__SWIG_6(L);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                return _wrap_new_HingeConstraint__SWIG_1(L);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                return _wrap_new_HingeConstraint__SWIG_5(L);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                {
                  _v = lua_isboolean(L,argv[6]);
                }
                if (_v) {
                  return _wrap_new_HingeConstraint__SWIG_4(L);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                {
                  _v = lua_isboolean(L,argv[6]);
                }
                if (_v) {
                  return _wrap_new_HingeConstraint__SWIG_0(L);
                }
              }
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_HingeConstraint'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::HingeConstraint::HingeConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &)\n");
  lua_error(L);return 0;
}


static int _wrap_HingeConstraint_SetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetPivotALocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotALocation",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotALocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotALocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotALocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetPivotBLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotBLocation",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotBLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotBLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotBLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetPivotALocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetPivotALocation",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->GetPivotALocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetPivotBLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetPivotBLocation",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->GetPivotBLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetAPivotRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetAPivotRotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetAPivotRotation",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetAPivotRotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetAPivotRotation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("HingeConstraint_SetAPivotRotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetAPivotRotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetBPivotRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetBPivotRotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetBPivotRotation",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetBPivotRotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetBPivotRotation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("HingeConstraint_SetBPivotRotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetBPivotRotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetAPivotRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetAPivotRotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetAPivotRotation",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetAPivotRotation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->GetAPivotRotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetBPivotRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetBPivotRotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetBPivotRotation",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetBPivotRotation",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->GetBPivotRotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetPivotATransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotATransform",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotATransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotATransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotATransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetPivotBTransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotBTransform",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetPivotBTransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("HingeConstraint_SetPivotBTransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotBTransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetPivotATransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetPivotATransform",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->GetPivotATransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetPivotBTransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetPivotBTransform",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->GetPivotBTransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_EnableMotor__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::EnableMotor",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::EnableMotor",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::EnableMotor",2,"Mezzanine::Boole");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::EnableMotor",3,"Mezzanine::Real");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::EnableMotor",4,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_EnableMotor",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real)lua_tonumber(L, 4);
  (arg1)->EnableMotor(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_EnableMotor__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::EnableMotor",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::EnableMotor",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::EnableMotor",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_EnableMotor",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->EnableMotor(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_EnableMotor(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isboolean(L,argv[1]);
      }
      if (_v) {
        return _wrap_HingeConstraint_EnableMotor__SWIG_1(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isboolean(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_HingeConstraint_EnableMotor__SWIG_0(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'HingeConstraint_EnableMotor'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::HingeConstraint::EnableMotor(Mezzanine::Boole,Mezzanine::Real,Mezzanine::Real)\n"
    "    Mezzanine::Physics::HingeConstraint::EnableMotor(Mezzanine::Boole)\n");
  lua_error(L);return 0;
}


static int _wrap_HingeConstraint_GetMotorEnabled(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetMotorEnabled",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetMotorEnabled",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetMotorEnabled",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetMotorEnabled();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetMaxMotorImpulse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetMaxMotorImpulse",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMaxMotorImpulse",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMaxMotorImpulse",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetMaxMotorImpulse",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetMaxMotorImpulse(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetMaxMotorImpulse(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetMaxMotorImpulse",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetMaxMotorImpulse",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetMaxMotorImpulse",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetMaxMotorImpulse();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetMotorTarget__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetMotorTarget",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTarget",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTarget",2,"Mezzanine::Quaternion const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTarget",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetMotorTarget",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("HingeConstraint_SetMotorTarget",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetMotorTarget((Mezzanine::Quaternion const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetMotorTarget__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetMotorTarget",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTarget",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTarget",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTarget",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetMotorTarget",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetMotorTarget(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetMotorTarget(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_HingeConstraint_SetMotorTarget__SWIG_0(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_HingeConstraint_SetMotorTarget__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'HingeConstraint_SetMotorTarget'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::HingeConstraint::SetMotorTarget(Mezzanine::Quaternion const &,Mezzanine::Real)\n"
    "    Mezzanine::Physics::HingeConstraint::SetMotorTarget(Mezzanine::Real,Mezzanine::Real)\n");
  lua_error(L);return 0;
}


static int _wrap_HingeConstraint_SetMotorTargetVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetMotorTargetVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTargetVelocity",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetMotorTargetVelocity",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetMotorTargetVelocity",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetMotorTargetVelocity(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetMotorTargetVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetMotorTargetVelocity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetMotorTargetVelocity",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetMotorTargetVelocity",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetMotorTargetVelocity();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetLimit__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  Mezzanine::Real arg6 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetLimit",6,6)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",3,"Mezzanine::Real");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",4,"Mezzanine::Real");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",5,"Mezzanine::Real");
  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",6,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetLimit",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real)lua_tonumber(L, 5);
  arg6 = (Mezzanine::Real)lua_tonumber(L, 6);
  (arg1)->SetLimit(arg2,arg3,arg4,arg5,arg6);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetLimit__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetLimit",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",3,"Mezzanine::Real");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",4,"Mezzanine::Real");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",5,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetLimit",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real)lua_tonumber(L, 5);
  (arg1)->SetLimit(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetLimit__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetLimit",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",3,"Mezzanine::Real");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",4,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetLimit",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real)lua_tonumber(L, 4);
  (arg1)->SetLimit(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetLimit__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetLimit",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetLimit",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetLimit",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetLimit(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetLimit(lua_State* L) {
  int argc;
  int argv[7]={
    1,2,3,4,5,6,7
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_HingeConstraint_SetLimit__SWIG_3(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_HingeConstraint_SetLimit__SWIG_2(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_HingeConstraint_SetLimit__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              {
                _v = lua_isnumber(L,argv[5]);
              }
              if (_v) {
                return _wrap_HingeConstraint_SetLimit__SWIG_0(L);
              }
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'HingeConstraint_SetLimit'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::HingeConstraint::SetLimit(Mezzanine::Real,Mezzanine::Real,Mezzanine::Real,Mezzanine::Real,Mezzanine::Real)\n"
    "    Mezzanine::Physics::HingeConstraint::SetLimit(Mezzanine::Real,Mezzanine::Real,Mezzanine::Real,Mezzanine::Real)\n"
    "    Mezzanine::Physics::HingeConstraint::SetLimit(Mezzanine::Real,Mezzanine::Real,Mezzanine::Real)\n"
    "    Mezzanine::Physics::HingeConstraint::SetLimit(Mezzanine::Real,Mezzanine::Real)\n");
  lua_error(L);return 0;
}


static int _wrap_HingeConstraint_GetLimitLow(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetLimitLow",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetLimitLow",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetLimitLow",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetLimitLow();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetLimitHigh(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetLimitHigh",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetLimitHigh",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetLimitHigh",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetLimitHigh();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetLimitSoftness(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetLimitSoftness",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetLimitSoftness",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetLimitSoftness",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetLimitSoftness();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetLimitBiasFactor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetLimitBiasFactor",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetLimitBiasFactor",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetLimitBiasFactor",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetLimitBiasFactor();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetLimitRelaxationFactor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetLimitRelaxationFactor",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetLimitRelaxationFactor",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetLimitRelaxationFactor",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetLimitRelaxationFactor();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetAxis",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetAxis",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetAxis",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("HingeConstraint_SetAxis",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAxis((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetHingeAngle(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetHingeAngle",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetHingeAngle",1,"Mezzanine::Physics::HingeConstraint *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetHingeAngle",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Real)(arg1)->GetHingeAngle();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_ValidParamOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::ValidParamOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ValidParamOnAxis",1,"Mezzanine::Physics::HingeConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ValidParamOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_ValidParamOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->ValidParamOnAxis(arg2);
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_ValidLinearAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::ValidLinearAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ValidLinearAxis",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_ValidLinearAxis",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->ValidLinearAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_ValidAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::ValidAngularAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ValidAngularAxis",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_ValidAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = ((Mezzanine::Physics::HingeConstraint const *)arg1)->ValidAngularAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_HasParamBeenSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::HasParamBeenSet",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HasParamBeenSet",1,"Mezzanine::Physics::HingeConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HasParamBeenSet",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::HasParamBeenSet",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_HasParamBeenSet",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::HingeConstraint const *)arg1)->HasParamBeenSet(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetUseFrameOffset(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetUseFrameOffset",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetUseFrameOffset",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetUseFrameOffset",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetUseFrameOffset();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetUseFrameOffset(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetUseFrameOffset",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetUseFrameOffset",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetUseFrameOffset",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetUseFrameOffset",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetUseFrameOffset(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_GetUseReferenceFrameA(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetUseReferenceFrameA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetUseReferenceFrameA",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetUseReferenceFrameA",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetUseReferenceFrameA();
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetUseReferenceFrameA__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetUseReferenceFrameA",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetUseReferenceFrameA(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetUseReferenceFrameA__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA",1,"Mezzanine::Physics::HingeConstraint *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_SetUseReferenceFrameA",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  (arg1)->SetUseReferenceFrameA();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SetUseReferenceFrameA(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_HingeConstraint_SetUseReferenceFrameA__SWIG_1(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__HingeConstraint, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isboolean(L,argv[1]);
      }
      if (_v) {
        return _wrap_HingeConstraint_SetUseReferenceFrameA__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'HingeConstraint_SetUseReferenceFrameA'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA(Mezzanine::Boole)\n"
    "    Mezzanine::Physics::HingeConstraint::SetUseReferenceFrameA()\n");
  lua_error(L);return 0;
}


static int _wrap_HingeConstraint_GetConstraintBase(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  btTypedConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::GetConstraintBase",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::GetConstraintBase",1,"Mezzanine::Physics::HingeConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_GetConstraintBase",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  result = (btTypedConstraint *)((Mezzanine::Physics::HingeConstraint const *)arg1)->GetConstraintBase();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btTypedConstraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ProtoSerialize",1,"Mezzanine::Physics::HingeConstraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("HingeConstraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::HingeConstraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ProtoDeSerialize",1,"Mezzanine::Physics::HingeConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::HingeConstraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,0))){
    SWIG_fail_ptr("HingeConstraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__HingeConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("HingeConstraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_HingeConstraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::HingeConstraint::SerializableName",0,0)
  result = Mezzanine::Physics::HingeConstraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_HingeConstraint(void *obj) {
Mezzanine::Physics::HingeConstraint *arg1 = (Mezzanine::Physics::HingeConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_HingeConstraint_methods[] = {
    {"SetPivotALocation", _wrap_HingeConstraint_SetPivotALocation}, 
    {"SetPivotBLocation", _wrap_HingeConstraint_SetPivotBLocation}, 
    {"GetPivotALocation", _wrap_HingeConstraint_GetPivotALocation}, 
    {"GetPivotBLocation", _wrap_HingeConstraint_GetPivotBLocation}, 
    {"SetAPivotRotation", _wrap_HingeConstraint_SetAPivotRotation}, 
    {"SetBPivotRotation", _wrap_HingeConstraint_SetBPivotRotation}, 
    {"GetAPivotRotation", _wrap_HingeConstraint_GetAPivotRotation}, 
    {"GetBPivotRotation", _wrap_HingeConstraint_GetBPivotRotation}, 
    {"SetPivotATransform", _wrap_HingeConstraint_SetPivotATransform}, 
    {"SetPivotBTransform", _wrap_HingeConstraint_SetPivotBTransform}, 
    {"GetPivotATransform", _wrap_HingeConstraint_GetPivotATransform}, 
    {"GetPivotBTransform", _wrap_HingeConstraint_GetPivotBTransform}, 
    {"EnableMotor", _wrap_HingeConstraint_EnableMotor}, 
    {"GetMotorEnabled", _wrap_HingeConstraint_GetMotorEnabled}, 
    {"SetMaxMotorImpulse", _wrap_HingeConstraint_SetMaxMotorImpulse}, 
    {"GetMaxMotorImpulse", _wrap_HingeConstraint_GetMaxMotorImpulse}, 
    {"SetMotorTarget", _wrap_HingeConstraint_SetMotorTarget}, 
    {"SetMotorTargetVelocity", _wrap_HingeConstraint_SetMotorTargetVelocity}, 
    {"GetMotorTargetVelocity", _wrap_HingeConstraint_GetMotorTargetVelocity}, 
    {"SetLimit", _wrap_HingeConstraint_SetLimit}, 
    {"GetLimitLow", _wrap_HingeConstraint_GetLimitLow}, 
    {"GetLimitHigh", _wrap_HingeConstraint_GetLimitHigh}, 
    {"GetLimitSoftness", _wrap_HingeConstraint_GetLimitSoftness}, 
    {"GetLimitBiasFactor", _wrap_HingeConstraint_GetLimitBiasFactor}, 
    {"GetLimitRelaxationFactor", _wrap_HingeConstraint_GetLimitRelaxationFactor}, 
    {"SetAxis", _wrap_HingeConstraint_SetAxis}, 
    {"GetHingeAngle", _wrap_HingeConstraint_GetHingeAngle}, 
    {"ValidParamOnAxis", _wrap_HingeConstraint_ValidParamOnAxis}, 
    {"ValidLinearAxis", _wrap_HingeConstraint_ValidLinearAxis}, 
    {"ValidAngularAxis", _wrap_HingeConstraint_ValidAngularAxis}, 
    {"HasParamBeenSet", _wrap_HingeConstraint_HasParamBeenSet}, 
    {"GetUseFrameOffset", _wrap_HingeConstraint_GetUseFrameOffset}, 
    {"SetUseFrameOffset", _wrap_HingeConstraint_SetUseFrameOffset}, 
    {"GetUseReferenceFrameA", _wrap_HingeConstraint_GetUseReferenceFrameA}, 
    {"SetUseReferenceFrameA", _wrap_HingeConstraint_SetUseReferenceFrameA}, 
    {"GetConstraintBase", _wrap_HingeConstraint_GetConstraintBase}, 
    {"ProtoSerialize", _wrap_HingeConstraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_HingeConstraint_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_HingeConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_HingeConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_HingeConstraint_base_names[] = {"Mezzanine::Physics::DualTransformConstraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_HingeConstraint = { "HingeConstraint", &SWIGTYPE_p_Mezzanine__Physics__HingeConstraint,_wrap_new_HingeConstraint, swig_delete_HingeConstraint, swig_Mezzanine_Physics_HingeConstraint_methods, swig_Mezzanine_Physics_HingeConstraint_attributes, swig_Mezzanine_Physics_HingeConstraint_bases, swig_Mezzanine_Physics_HingeConstraint_base_names };

static int _wrap_ManagerConstructionInfo_PhysicsFlags_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Whole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::PhysicsFlags",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::PhysicsFlags",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::PhysicsFlags",2,"Mezzanine::Whole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_PhysicsFlags_set",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
  if (arg1) (arg1)->PhysicsFlags = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_PhysicsFlags_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::PhysicsFlags",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::PhysicsFlags",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_PhysicsFlags_get",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  result = (Mezzanine::Whole) ((arg1)->PhysicsFlags);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_MaxProxies_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Whole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::MaxProxies",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::MaxProxies",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::MaxProxies",2,"Mezzanine::Whole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_MaxProxies_set",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
  if (arg1) (arg1)->MaxProxies = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_MaxProxies_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::MaxProxies",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::MaxProxies",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_MaxProxies_get",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  result = (Mezzanine::Whole) ((arg1)->MaxProxies);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_GeographyLowerBounds_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = (Mezzanine::Physics::Vector3 *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::GeographyLowerBounds",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::GeographyLowerBounds",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::GeographyLowerBounds",2,"Mezzanine::Physics::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_GeographyLowerBounds_set",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_GeographyLowerBounds_set",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  if (arg1) (arg1)->GeographyLowerBounds = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_GeographyLowerBounds_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Physics::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::GeographyLowerBounds",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::GeographyLowerBounds",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_GeographyLowerBounds_get",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  result = (Mezzanine::Physics::Vector3 *)& ((arg1)->GeographyLowerBounds);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_GeographyUpperBounds_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = (Mezzanine::Physics::Vector3 *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::GeographyUpperBounds",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::GeographyUpperBounds",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::GeographyUpperBounds",2,"Mezzanine::Physics::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_GeographyUpperBounds_set",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_GeographyUpperBounds_set",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  if (arg1) (arg1)->GeographyUpperBounds = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_GeographyUpperBounds_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Physics::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::GeographyUpperBounds",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::GeographyUpperBounds",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_GeographyUpperBounds_get",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  result = (Mezzanine::Physics::Vector3 *)& ((arg1)->GeographyUpperBounds);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_Gravity_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = (Mezzanine::Physics::Vector3 *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::Gravity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::Gravity",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::Gravity",2,"Mezzanine::Physics::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_Gravity_set",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_Gravity_set",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  if (arg1) (arg1)->Gravity = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_ManagerConstructionInfo_Gravity_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) 0 ;
  Mezzanine::Physics::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::Gravity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::ManagerConstructionInfo::Gravity",1,"Mezzanine::Physics::ManagerConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,0))){
    SWIG_fail_ptr("ManagerConstructionInfo_Gravity_get",1,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo);
  }
  
  result = (Mezzanine::Physics::Vector3 *)& ((arg1)->Gravity);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_ManagerConstructionInfo(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::ManagerConstructionInfo *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::ManagerConstructionInfo::ManagerConstructionInfo",0,0)
  result = (Mezzanine::Physics::ManagerConstructionInfo *)new Mezzanine::Physics::ManagerConstructionInfo();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_ManagerConstructionInfo(void *obj) {
Mezzanine::Physics::ManagerConstructionInfo *arg1 = (Mezzanine::Physics::ManagerConstructionInfo *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_ManagerConstructionInfo_methods[] = {
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_ManagerConstructionInfo_attributes[] = {
    { "PhysicsFlags", _wrap_ManagerConstructionInfo_PhysicsFlags_get, _wrap_ManagerConstructionInfo_PhysicsFlags_set},
    { "MaxProxies", _wrap_ManagerConstructionInfo_MaxProxies_get, _wrap_ManagerConstructionInfo_MaxProxies_set},
    { "GeographyLowerBounds", _wrap_ManagerConstructionInfo_GeographyLowerBounds_get, _wrap_ManagerConstructionInfo_GeographyLowerBounds_set},
    { "GeographyUpperBounds", _wrap_ManagerConstructionInfo_GeographyUpperBounds_get, _wrap_ManagerConstructionInfo_GeographyUpperBounds_set},
    { "Gravity", _wrap_ManagerConstructionInfo_Gravity_get, _wrap_ManagerConstructionInfo_Gravity_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_ManagerConstructionInfo_bases[] = {0};
static const char *swig_Mezzanine_Physics_ManagerConstructionInfo_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_ManagerConstructionInfo = { "ManagerConstructionInfo", &SWIGTYPE_p_Mezzanine__Physics__ManagerConstructionInfo,_wrap_new_ManagerConstructionInfo, swig_delete_ManagerConstructionInfo, swig_Mezzanine_Physics_ManagerConstructionInfo_methods, swig_Mezzanine_Physics_ManagerConstructionInfo_attributes, swig_Mezzanine_Physics_ManagerConstructionInfo_bases, swig_Mezzanine_Physics_ManagerConstructionInfo_base_names };

static int _wrap_new_MultiSphereCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  std::vector< Mezzanine::Physics::Vector3 > *arg2 = 0 ;
  std::vector< Mezzanine::Real > *arg3 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::MultiSphereCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",3,3)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",2,"std::vector< Mezzanine::Physics::Vector3 > const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",3,"std::vector< Mezzanine::Real > const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t,0))){
    SWIG_fail_ptr("new_MultiSphereCollisionShape",2,SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_float_t,0))){
    SWIG_fail_ptr("new_MultiSphereCollisionShape",3,SWIGTYPE_p_std__vectorT_float_t);
  }
  
  result = (Mezzanine::Physics::MultiSphereCollisionShape *)new Mezzanine::Physics::MultiSphereCollisionShape((Mezzanine::String const &)*arg1,(std::vector< Mezzanine::Physics::Vector3 > const &)*arg2,(std::vector< Mezzanine::Real > const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MultiSphereCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btMultiSphereShape *arg2 = (btMultiSphereShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::MultiSphereCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",2,"btMultiSphereShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btMultiSphereShape,0))){
    SWIG_fail_ptr("new_MultiSphereCollisionShape",2,SWIGTYPE_p_btMultiSphereShape);
  }
  
  result = (Mezzanine::Physics::MultiSphereCollisionShape *)new Mezzanine::Physics::MultiSphereCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MultiSphereCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::MultiSphereCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_MultiSphereCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::MultiSphereCollisionShape *)new Mezzanine::Physics::MultiSphereCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_MultiSphereCollisionShape(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_MultiSphereCollisionShape__SWIG_2(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btMultiSphereShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_MultiSphereCollisionShape__SWIG_1(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_Mezzanine__Vector3_t, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_float_t, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_MultiSphereCollisionShape__SWIG_0(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_MultiSphereCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape(Mezzanine::String const &,std::vector< Mezzanine::Physics::Vector3 > const &,std::vector< Mezzanine::Real > const &)\n"
    "    Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape(Mezzanine::String const &,btMultiSphereShape *)\n"
    "    Mezzanine::Physics::MultiSphereCollisionShape::MultiSphereCollisionShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_MultiSphereCollisionShape_GetSphereLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::GetSphereLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetSphereLocation",1,"Mezzanine::Physics::MultiSphereCollisionShape const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetSphereLocation",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_GetSphereLocation",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = ((Mezzanine::Physics::MultiSphereCollisionShape const *)arg1)->GetSphereLocation((Mezzanine::Whole const &)*arg2);
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_GetSphereRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  Mezzanine::Whole *arg2 = 0 ;
  Mezzanine::Whole temp2 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::GetSphereRadius",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetSphereRadius",1,"Mezzanine::Physics::MultiSphereCollisionShape const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetSphereRadius",2,"Mezzanine::Whole const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_GetSphereRadius",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  temp2=(Mezzanine::Whole)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Real)((Mezzanine::Physics::MultiSphereCollisionShape const *)arg1)->GetSphereRadius((Mezzanine::Whole const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_GetNumSpheres(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::GetNumSpheres",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetNumSpheres",1,"Mezzanine::Physics::MultiSphereCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_GetNumSpheres",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  result = (Mezzanine::Whole)((Mezzanine::Physics::MultiSphereCollisionShape const *)arg1)->GetNumSpheres();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetType",1,"Mezzanine::Physics::MultiSphereCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::MultiSphereCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_GetMultiSphereShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  btMultiSphereShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::GetMultiSphereShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::GetMultiSphereShape",1,"Mezzanine::Physics::MultiSphereCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_GetMultiSphereShape",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  result = (btMultiSphereShape *)((Mezzanine::Physics::MultiSphereCollisionShape const *)arg1)->GetMultiSphereShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btMultiSphereShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::MultiSphereCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::MultiSphereCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::MultiSphereCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::MultiSphereCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("MultiSphereCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_MultiSphereCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::MultiSphereCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::MultiSphereCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_MultiSphereCollisionShape(void *obj) {
Mezzanine::Physics::MultiSphereCollisionShape *arg1 = (Mezzanine::Physics::MultiSphereCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_MultiSphereCollisionShape_methods[] = {
    {"GetSphereLocation", _wrap_MultiSphereCollisionShape_GetSphereLocation}, 
    {"GetSphereRadius", _wrap_MultiSphereCollisionShape_GetSphereRadius}, 
    {"GetNumSpheres", _wrap_MultiSphereCollisionShape_GetNumSpheres}, 
    {"GetType", _wrap_MultiSphereCollisionShape_GetType}, 
    {"GetMultiSphereShape", _wrap_MultiSphereCollisionShape_GetMultiSphereShape}, 
    {"ProtoSerialize", _wrap_MultiSphereCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_MultiSphereCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_MultiSphereCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_MultiSphereCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_MultiSphereCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_MultiSphereCollisionShape = { "MultiSphereCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__MultiSphereCollisionShape,_wrap_new_MultiSphereCollisionShape, swig_delete_MultiSphereCollisionShape, swig_Mezzanine_Physics_MultiSphereCollisionShape_methods, swig_Mezzanine_Physics_MultiSphereCollisionShape_attributes, swig_Mezzanine_Physics_MultiSphereCollisionShape_bases, swig_Mezzanine_Physics_MultiSphereCollisionShape_base_names };

static int _wrap_Plane_Normal_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = (Mezzanine::Vector3 *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Normal",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Normal",1,"Mezzanine::Plane *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Plane::Normal",2,"Mezzanine::Vector3 *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Normal_set",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Normal_set",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  if (arg1) (arg1)->Normal = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_Normal_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Normal",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Normal",1,"Mezzanine::Plane *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Normal_get",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = (Mezzanine::Vector3 *)& ((arg1)->Normal);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Vector3,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_Distance_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Distance",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Distance",1,"Mezzanine::Plane *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Plane::Distance",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Distance_set",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  if (arg1) (arg1)->Distance = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_Distance_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Plane::Distance",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Distance",1,"Mezzanine::Plane *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Distance_get",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = (Mezzanine::Real) ((arg1)->Distance);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Plane",0,0)
  result = (Mezzanine::Plane *)new Mezzanine::Plane();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Plane,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = 0 ;
  Mezzanine::Plane *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Plane",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Plane::Plane",1,"Mezzanine::Plane const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("new_Plane",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = (Mezzanine::Plane *)new Mezzanine::Plane((Mezzanine::Plane const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Plane,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Plane *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Plane",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Plane::Plane",1,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Plane::Plane",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Plane",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  result = (Mezzanine::Plane *)new Mezzanine::Plane((Mezzanine::Vector3 const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Plane,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Plane *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Plane",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Plane::Plane",1,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::Plane",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Plane",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Plane",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Plane *)new Mezzanine::Plane((Mezzanine::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Plane,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane__SWIG_4(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Vector3 *arg1 = 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Plane *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Plane",3,3)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Plane::Plane",1,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::Plane",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Plane::Plane",3,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Plane",1,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Plane",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Plane",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Plane *)new Mezzanine::Plane((Mezzanine::Vector3 const &)*arg1,(Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Plane,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane__SWIG_5(lua_State* L) {
  int SWIG_arg = 0;
  Ogre::Plane *arg1 = 0 ;
  Mezzanine::Plane *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Plane",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Plane::Plane",1,"Ogre::Plane const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Ogre__Plane,0))){
    SWIG_fail_ptr("new_Plane",1,SWIGTYPE_p_Ogre__Plane);
  }
  
  result = (Mezzanine::Plane *)new Mezzanine::Plane((Ogre::Plane const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Plane,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Plane(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_Plane__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Plane__SWIG_1(L);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Ogre__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_Plane__SWIG_5(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_Plane__SWIG_3(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_new_Plane__SWIG_2(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_Plane__SWIG_4(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Plane'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Plane::Plane()\n"
    "    Mezzanine::Plane::Plane(Mezzanine::Plane const &)\n"
    "    Mezzanine::Plane::Plane(Mezzanine::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::Plane::Plane(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Plane::Plane(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Plane::Plane(Ogre::Plane const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Plane_Define__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Define",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Define",1,"Mezzanine::Plane *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::Define",2,"Mezzanine::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Plane::Define",3,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Define",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Define",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  (arg1)->Define((Mezzanine::Vector3 const &)*arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_Define__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Define",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Define",1,"Mezzanine::Plane *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::Define",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Plane::Define",3,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Define",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Define",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Define",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Define((Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_Define__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Vector3 *arg4 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::Define",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Define",1,"Mezzanine::Plane *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::Define",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Plane::Define",3,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Plane::Define",4,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Define",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Define",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Define",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_Define",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->Define((Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3,(Mezzanine::Vector3 const &)*arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_Define(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_Plane_Define__SWIG_1(L);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_Plane_Define__SWIG_0(L);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_Plane_Define__SWIG_2(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Plane_Define'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Plane::Define(Mezzanine::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::Plane::Define(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &)\n"
    "    Mezzanine::Plane::Define(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &,Mezzanine::Vector3 const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Plane_GetSide__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Plane::Side result;
  
  SWIG_check_num_args("Mezzanine::Plane::GetSide",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::GetSide",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::GetSide",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_GetSide",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_GetSide",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Plane::Side)((Mezzanine::Plane const *)arg1)->GetSide((Mezzanine::Vector3 const &)*arg2);
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_GetSide__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Vector3 *arg3 = 0 ;
  Mezzanine::Plane::Side result;
  
  SWIG_check_num_args("Mezzanine::Plane::GetSide",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::GetSide",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::GetSide",2,"Mezzanine::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Plane::GetSide",3,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_GetSide",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_GetSide",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_GetSide",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Plane::Side)((Mezzanine::Plane const *)arg1)->GetSide((Mezzanine::Vector3 const &)*arg2,(Mezzanine::Vector3 const &)*arg3);
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_GetSide(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Plane_GetSide__SWIG_0(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_Plane_GetSide__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Plane_GetSide'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Plane::GetSide(Mezzanine::Vector3 const &) const\n"
    "    Mezzanine::Plane::GetSide(Mezzanine::Vector3 const &,Mezzanine::Vector3 const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Plane_GetDistance(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Vector3 *arg2 = 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Plane::GetDistance",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::GetDistance",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::GetDistance",2,"Mezzanine::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_GetDistance",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Plane_GetDistance",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Plane const *)arg1)->GetDistance((Mezzanine::Vector3 const &)*arg2);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_IsOverlapping__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Sphere *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Plane::IsOverlapping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::IsOverlapping",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::IsOverlapping",2,"Mezzanine::Sphere const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_IsOverlapping",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Sphere,0))){
    SWIG_fail_ptr("Plane_IsOverlapping",2,SWIGTYPE_p_Mezzanine__Sphere);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Plane const *)arg1)->IsOverlapping((Mezzanine::Sphere const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_IsOverlapping__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::AxisAlignedBox *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Plane::IsOverlapping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::IsOverlapping",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::IsOverlapping",2,"Mezzanine::AxisAlignedBox const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_IsOverlapping",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__AxisAlignedBox,0))){
    SWIG_fail_ptr("Plane_IsOverlapping",2,SWIGTYPE_p_Mezzanine__AxisAlignedBox);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Plane const *)arg1)->IsOverlapping((Mezzanine::AxisAlignedBox const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_IsOverlapping__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Plane *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Plane::IsOverlapping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::IsOverlapping",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::IsOverlapping",2,"Mezzanine::Plane const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_IsOverlapping",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_IsOverlapping",2,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Plane const *)arg1)->IsOverlapping((Mezzanine::Plane const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_IsOverlapping(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Sphere, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Plane_IsOverlapping__SWIG_0(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__AxisAlignedBox, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Plane_IsOverlapping__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_Plane_IsOverlapping__SWIG_2(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'Plane_IsOverlapping'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Plane::IsOverlapping(Mezzanine::Sphere const &) const\n"
    "    Mezzanine::Plane::IsOverlapping(Mezzanine::AxisAlignedBox const &) const\n"
    "    Mezzanine::Plane::IsOverlapping(Mezzanine::Plane const &) const\n");
  lua_error(L);return 0;
}


static int _wrap_Plane_Intersects(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Ray *arg2 = 0 ;
  SwigValueWrapper< std::pair< bool,Mezzanine::Vector3 > > result;
  
  SWIG_check_num_args("Mezzanine::Plane::Intersects",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::Intersects",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::Intersects",2,"Mezzanine::Ray const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_Intersects",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Ray,0))){
    SWIG_fail_ptr("Plane_Intersects",2,SWIGTYPE_p_Mezzanine__Ray);
  }
  
  result = ((Mezzanine::Plane const *)arg1)->Intersects((Mezzanine::Ray const &)*arg2);
  {
    Mezzanine::Plane::RayTestResult * resultptr = new Mezzanine::Plane::RayTestResult((const Mezzanine::Plane::RayTestResult &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__pairT_bool_Mezzanine__Vector3_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_ExtractOgrePlane(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Ogre::Plane *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::ExtractOgrePlane",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::ExtractOgrePlane",1,"Mezzanine::Plane *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::ExtractOgrePlane",2,"Ogre::Plane const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_ExtractOgrePlane",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Ogre__Plane,0))){
    SWIG_fail_ptr("Plane_ExtractOgrePlane",2,SWIGTYPE_p_Ogre__Plane);
  }
  
  (arg1)->ExtractOgrePlane((Ogre::Plane const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_GetOgrePlane(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Ogre::Plane result;
  
  SWIG_check_num_args("Mezzanine::Plane::GetOgrePlane",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::GetOgrePlane",1,"Mezzanine::Plane const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_GetOgrePlane",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = ((Mezzanine::Plane const *)arg1)->GetOgrePlane();
  {
    Ogre::Plane * resultptr = new Ogre::Plane((const Ogre::Plane &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Ogre__Plane,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::ProtoSerialize",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Plane_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Plane const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Plane::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::ProtoDeSerialize",1,"Mezzanine::Plane *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Plane_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane_GetSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Plane::GetSerializableName",0,0)
  result = Mezzanine::Plane::GetSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Plane___eq(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Plane *arg1 = (Mezzanine::Plane *) 0 ;
  Mezzanine::Plane *arg2 = 0 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Plane::operator ==",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Plane::operator ==",1,"Mezzanine::Plane const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Plane::operator ==",2,"Mezzanine::Plane const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane___eq",1,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("Plane___eq",2,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = (Mezzanine::Boole)((Mezzanine::Plane const *)arg1)->operator ==((Mezzanine::Plane const &)*arg2);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Plane(void *obj) {
Mezzanine::Plane *arg1 = (Mezzanine::Plane *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Plane_methods[] = {
    {"Define", _wrap_Plane_Define}, 
    {"GetSide", _wrap_Plane_GetSide}, 
    {"GetDistance", _wrap_Plane_GetDistance}, 
    {"IsOverlapping", _wrap_Plane_IsOverlapping}, 
    {"Intersects", _wrap_Plane_Intersects}, 
    {"ExtractOgrePlane", _wrap_Plane_ExtractOgrePlane}, 
    {"GetOgrePlane", _wrap_Plane_GetOgrePlane}, 
    {"ProtoSerialize", _wrap_Plane_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Plane_ProtoDeSerialize}, 
    {"__eq", _wrap_Plane___eq}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Plane_attributes[] = {
    { "Normal", _wrap_Plane_Normal_get, _wrap_Plane_Normal_set},
    { "Distance", _wrap_Plane_Distance_get, _wrap_Plane_Distance_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Plane_bases[] = {0};
static const char *swig_Mezzanine_Plane_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Plane = { "Plane", &SWIGTYPE_p_Mezzanine__Plane,_wrap_new_Plane, swig_delete_Plane, swig_Mezzanine_Plane_methods, swig_Mezzanine_Plane_attributes, swig_Mezzanine_Plane_bases, swig_Mezzanine_Plane_base_names };

static int _wrap_new_PlaneCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Plane *arg2 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::PlaneCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",2,"Mezzanine::Plane const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Plane,0))){
    SWIG_fail_ptr("new_PlaneCollisionShape",2,SWIGTYPE_p_Mezzanine__Plane);
  }
  
  result = (Mezzanine::Physics::PlaneCollisionShape *)new Mezzanine::Physics::PlaneCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Plane const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PlaneCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Real arg3 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::PlaneCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",3,3)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",3,"Mezzanine::Real const");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_PlaneCollisionShape",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  result = (Mezzanine::Physics::PlaneCollisionShape *)new Mezzanine::Physics::PlaneCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Physics::Vector3 const &)*arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PlaneCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btStaticPlaneShape *arg2 = (btStaticPlaneShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::PlaneCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",2,"btStaticPlaneShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btStaticPlaneShape,0))){
    SWIG_fail_ptr("new_PlaneCollisionShape",2,SWIGTYPE_p_btStaticPlaneShape);
  }
  
  result = (Mezzanine::Physics::PlaneCollisionShape *)new Mezzanine::Physics::PlaneCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PlaneCollisionShape__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Physics::PlaneCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape",1,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_PlaneCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  
  result = (Mezzanine::Physics::PlaneCollisionShape *)new Mezzanine::Physics::PlaneCollisionShape((XML::Node const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_PlaneCollisionShape(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_PlaneCollisionShape__SWIG_3(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btStaticPlaneShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_PlaneCollisionShape__SWIG_2(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Plane, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_PlaneCollisionShape__SWIG_0(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          return _wrap_new_PlaneCollisionShape__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_PlaneCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape(Mezzanine::String const &,Mezzanine::Plane const &)\n"
    "    Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape(Mezzanine::String const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Real const)\n"
    "    Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape(Mezzanine::String const &,btStaticPlaneShape *)\n"
    "    Mezzanine::Physics::PlaneCollisionShape::PlaneCollisionShape(XML::Node const &)\n");
  lua_error(L);return 0;
}


static int _wrap_PlaneCollisionShape_GetNormal(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PlaneCollisionShape *arg1 = (Mezzanine::Physics::PlaneCollisionShape *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::GetNormal",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::GetNormal",1,"Mezzanine::Physics::PlaneCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,0))){
    SWIG_fail_ptr("PlaneCollisionShape_GetNormal",1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape);
  }
  
  result = ((Mezzanine::Physics::PlaneCollisionShape const *)arg1)->GetNormal();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PlaneCollisionShape_GetConstant(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PlaneCollisionShape *arg1 = (Mezzanine::Physics::PlaneCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::GetConstant",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::GetConstant",1,"Mezzanine::Physics::PlaneCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,0))){
    SWIG_fail_ptr("PlaneCollisionShape_GetConstant",1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::PlaneCollisionShape const *)arg1)->GetConstant();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PlaneCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PlaneCollisionShape *arg1 = (Mezzanine::Physics::PlaneCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::GetType",1,"Mezzanine::Physics::PlaneCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,0))){
    SWIG_fail_ptr("PlaneCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::PlaneCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PlaneCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PlaneCollisionShape *arg1 = (Mezzanine::Physics::PlaneCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::PlaneCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,0))){
    SWIG_fail_ptr("PlaneCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PlaneCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::PlaneCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PlaneCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::PlaneCollisionShape *arg1 = (Mezzanine::Physics::PlaneCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::PlaneCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::PlaneCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,0))){
    SWIG_fail_ptr("PlaneCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("PlaneCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_PlaneCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::PlaneCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::PlaneCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_PlaneCollisionShape(void *obj) {
Mezzanine::Physics::PlaneCollisionShape *arg1 = (Mezzanine::Physics::PlaneCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_PlaneCollisionShape_methods[] = {
    {"GetNormal", _wrap_PlaneCollisionShape_GetNormal}, 
    {"GetConstant", _wrap_PlaneCollisionShape_GetConstant}, 
    {"GetType", _wrap_PlaneCollisionShape_GetType}, 
    {"ProtoSerialize", _wrap_PlaneCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_PlaneCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_PlaneCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_PlaneCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_PlaneCollisionShape_base_names[] = {"Mezzanine::Physics::FieldCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_PlaneCollisionShape = { "PlaneCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__PlaneCollisionShape,_wrap_new_PlaneCollisionShape, swig_delete_PlaneCollisionShape, swig_Mezzanine_Physics_PlaneCollisionShape_methods, swig_Mezzanine_Physics_PlaneCollisionShape_attributes, swig_Mezzanine_Physics_PlaneCollisionShape_bases, swig_Mezzanine_Physics_PlaneCollisionShape_base_names };

static int _wrap_new_Point2PointConstraint__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Physics::Point2PointConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",4,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Point2PointConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Point2PointConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Point2PointConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Point2PointConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::Point2PointConstraint *)new Mezzanine::Physics::Point2PointConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Point2PointConstraint__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Physics::Point2PointConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_Point2PointConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_Point2PointConstraint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::Point2PointConstraint *)new Mezzanine::Physics::Point2PointConstraint(arg1,(Mezzanine::Physics::Vector3 const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_Point2PointConstraint(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_Point2PointConstraint__SWIG_1(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_Point2PointConstraint__SWIG_0(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Point2PointConstraint'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::Point2PointConstraint::Point2PointConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &)\n");
  lua_error(L);return 0;
}


static int _wrap_Point2PointConstraint_SetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::SetPivotALocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetPivotALocation",1,"Mezzanine::Physics::Point2PointConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetPivotALocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetPivotALocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotALocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_SetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::SetPivotBLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetPivotBLocation",1,"Mezzanine::Physics::Point2PointConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetPivotBLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetPivotBLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotBLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_GetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::GetPivotALocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::GetPivotALocation",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_GetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = ((Mezzanine::Physics::Point2PointConstraint const *)arg1)->GetPivotALocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_GetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::GetPivotBLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::GetPivotBLocation",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_GetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = ((Mezzanine::Physics::Point2PointConstraint const *)arg1)->GetPivotBLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_SetImpulseClamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::SetImpulseClamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetImpulseClamping",1,"Mezzanine::Physics::Point2PointConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetImpulseClamping",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetImpulseClamping",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetImpulseClamping(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_GetImpulseClamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::GetImpulseClamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::GetImpulseClamping",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_GetImpulseClamping",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::Point2PointConstraint const *)arg1)->GetImpulseClamping();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_SetDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::SetDamping",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetDamping",1,"Mezzanine::Physics::Point2PointConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetDamping",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetDamping",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetDamping(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_GetDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::GetDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::GetDamping",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_GetDamping",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::Point2PointConstraint const *)arg1)->GetDamping();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_SetTAU(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::SetTAU",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetTAU",1,"Mezzanine::Physics::Point2PointConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::SetTAU",2,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_SetTAU",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  (arg1)->SetTAU(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_GetTAU(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::GetTAU",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::GetTAU",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_GetTAU",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::Point2PointConstraint const *)arg1)->GetTAU();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_ValidParamOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::ValidParamOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ValidParamOnAxis",1,"Mezzanine::Physics::Point2PointConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ValidParamOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_ValidParamOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = ((Mezzanine::Physics::Point2PointConstraint const *)arg1)->ValidParamOnAxis(arg2);
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_ValidLinearAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::ValidLinearAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ValidLinearAxis",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_ValidLinearAxis",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = ((Mezzanine::Physics::Point2PointConstraint const *)arg1)->ValidLinearAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_ValidAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::ValidAngularAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ValidAngularAxis",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_ValidAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = ((Mezzanine::Physics::Point2PointConstraint const *)arg1)->ValidAngularAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_HasParamBeenSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::HasParamBeenSet",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::HasParamBeenSet",1,"Mezzanine::Physics::Point2PointConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::HasParamBeenSet",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::HasParamBeenSet",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_HasParamBeenSet",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::Point2PointConstraint const *)arg1)->HasParamBeenSet(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_GetConstraintBase(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  btTypedConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::GetConstraintBase",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::GetConstraintBase",1,"Mezzanine::Physics::Point2PointConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_GetConstraintBase",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  result = (btTypedConstraint *)((Mezzanine::Physics::Point2PointConstraint const *)arg1)->GetConstraintBase();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btTypedConstraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ProtoSerialize",1,"Mezzanine::Physics::Point2PointConstraint const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Point2PointConstraint_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::Point2PointConstraint const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ProtoDeSerialize",1,"Mezzanine::Physics::Point2PointConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::Point2PointConstraint::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,0))){
    SWIG_fail_ptr("Point2PointConstraint_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("Point2PointConstraint_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_Point2PointConstraint_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::Point2PointConstraint::SerializableName",0,0)
  result = Mezzanine::Physics::Point2PointConstraint::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_Point2PointConstraint(void *obj) {
Mezzanine::Physics::Point2PointConstraint *arg1 = (Mezzanine::Physics::Point2PointConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_Point2PointConstraint_methods[] = {
    {"SetPivotALocation", _wrap_Point2PointConstraint_SetPivotALocation}, 
    {"SetPivotBLocation", _wrap_Point2PointConstraint_SetPivotBLocation}, 
    {"GetPivotALocation", _wrap_Point2PointConstraint_GetPivotALocation}, 
    {"GetPivotBLocation", _wrap_Point2PointConstraint_GetPivotBLocation}, 
    {"SetImpulseClamping", _wrap_Point2PointConstraint_SetImpulseClamping}, 
    {"GetImpulseClamping", _wrap_Point2PointConstraint_GetImpulseClamping}, 
    {"SetDamping", _wrap_Point2PointConstraint_SetDamping}, 
    {"GetDamping", _wrap_Point2PointConstraint_GetDamping}, 
    {"SetTAU", _wrap_Point2PointConstraint_SetTAU}, 
    {"GetTAU", _wrap_Point2PointConstraint_GetTAU}, 
    {"ValidParamOnAxis", _wrap_Point2PointConstraint_ValidParamOnAxis}, 
    {"ValidLinearAxis", _wrap_Point2PointConstraint_ValidLinearAxis}, 
    {"ValidAngularAxis", _wrap_Point2PointConstraint_ValidAngularAxis}, 
    {"HasParamBeenSet", _wrap_Point2PointConstraint_HasParamBeenSet}, 
    {"GetConstraintBase", _wrap_Point2PointConstraint_GetConstraintBase}, 
    {"ProtoSerialize", _wrap_Point2PointConstraint_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_Point2PointConstraint_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_Point2PointConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_Point2PointConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_Point2PointConstraint_base_names[] = {"Mezzanine::Physics::Constraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_Point2PointConstraint = { "Point2PointConstraint", &SWIGTYPE_p_Mezzanine__Physics__Point2PointConstraint,_wrap_new_Point2PointConstraint, swig_delete_Point2PointConstraint, swig_Mezzanine_Physics_Point2PointConstraint_methods, swig_Mezzanine_Physics_Point2PointConstraint_attributes, swig_Mezzanine_Physics_Point2PointConstraint_bases, swig_Mezzanine_Physics_Point2PointConstraint_base_names };

static int _wrap_StickyConstraintConstructionInfo_TransA_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Transform *arg2 = (Mezzanine::Transform *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::TransA",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::TransA",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::TransA",2,"Mezzanine::Transform *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_TransA_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_TransA_set",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  if (arg1) (arg1)->TransA = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_TransA_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::TransA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::TransA",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_TransA_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  result = (Mezzanine::Transform *)& ((arg1)->TransA);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_TransB_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Transform *arg2 = (Mezzanine::Transform *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::TransB",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::TransB",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::TransB",2,"Mezzanine::Transform *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_TransB_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_TransB_set",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  if (arg1) (arg1)->TransB = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_TransB_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Transform *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::TransB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::TransB",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_TransB_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  result = (Mezzanine::Transform *)& ((arg1)->TransB);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Transform,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_ProxA_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxA",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxA",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxA",2,"Mezzanine::Physics::RigidProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_ProxA_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,SWIG_POINTER_DISOWN))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_ProxA_set",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  if (arg1) (arg1)->ProxA = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_ProxA_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxA",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxA",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_ProxA_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  result = (Mezzanine::Physics::RigidProxy *) ((arg1)->ProxA);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_ProxB_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxB",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxB",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxB",2,"Mezzanine::Physics::RigidProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_ProxB_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,SWIG_POINTER_DISOWN))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_ProxB_set",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  if (arg1) (arg1)->ProxB = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyConstraintConstructionInfo_ProxB_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxB",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::ProxB",1,"Mezzanine::Physics::StickyConstraintConstructionInfo *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("StickyConstraintConstructionInfo_ProxB_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  result = (Mezzanine::Physics::RigidProxy *) ((arg1)->ProxB);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_StickyConstraintConstructionInfo__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::StickyConstraintConstructionInfo",0,0)
  result = (Mezzanine::Physics::StickyConstraintConstructionInfo *)new Mezzanine::Physics::StickyConstraintConstructionInfo();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_StickyConstraintConstructionInfo__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = 0 ;
  Mezzanine::Physics::StickyConstraintConstructionInfo *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyConstraintConstructionInfo::StickyConstraintConstructionInfo",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyConstraintConstructionInfo::StickyConstraintConstructionInfo",1,"Mezzanine::Physics::StickyConstraintConstructionInfo const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,0))){
    SWIG_fail_ptr("new_StickyConstraintConstructionInfo",1,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo);
  }
  
  result = (Mezzanine::Physics::StickyConstraintConstructionInfo *)new Mezzanine::Physics::StickyConstraintConstructionInfo((Mezzanine::Physics::StickyConstraintConstructionInfo const &)*arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_StickyConstraintConstructionInfo(lua_State* L) {
  int argc;
  int argv[2]={
    1,2
  };
  
  argc = lua_gettop(L);
  if (argc == 0) {
    return _wrap_new_StickyConstraintConstructionInfo__SWIG_0(L);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_StickyConstraintConstructionInfo__SWIG_1(L);
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_StickyConstraintConstructionInfo'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::StickyConstraintConstructionInfo::StickyConstraintConstructionInfo()\n"
    "    Mezzanine::Physics::StickyConstraintConstructionInfo::StickyConstraintConstructionInfo(Mezzanine::Physics::StickyConstraintConstructionInfo const &)\n");
  lua_error(L);return 0;
}


static void swig_delete_StickyConstraintConstructionInfo(void *obj) {
Mezzanine::Physics::StickyConstraintConstructionInfo *arg1 = (Mezzanine::Physics::StickyConstraintConstructionInfo *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_StickyConstraintConstructionInfo_methods[] = {
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_StickyConstraintConstructionInfo_attributes[] = {
    { "TransA", _wrap_StickyConstraintConstructionInfo_TransA_get, _wrap_StickyConstraintConstructionInfo_TransA_set},
    { "TransB", _wrap_StickyConstraintConstructionInfo_TransB_get, _wrap_StickyConstraintConstructionInfo_TransB_set},
    { "ProxA", _wrap_StickyConstraintConstructionInfo_ProxA_get, _wrap_StickyConstraintConstructionInfo_ProxA_set},
    { "ProxB", _wrap_StickyConstraintConstructionInfo_ProxB_get, _wrap_StickyConstraintConstructionInfo_ProxB_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_StickyConstraintConstructionInfo_bases[] = {0};
static const char *swig_Mezzanine_Physics_StickyConstraintConstructionInfo_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_StickyConstraintConstructionInfo = { "StickyConstraintConstructionInfo", &SWIGTYPE_p_Mezzanine__Physics__StickyConstraintConstructionInfo,_wrap_new_StickyConstraintConstructionInfo, swig_delete_StickyConstraintConstructionInfo, swig_Mezzanine_Physics_StickyConstraintConstructionInfo_methods, swig_Mezzanine_Physics_StickyConstraintConstructionInfo_attributes, swig_Mezzanine_Physics_StickyConstraintConstructionInfo_bases, swig_Mezzanine_Physics_StickyConstraintConstructionInfo_base_names };

static int _wrap_new_StickyData(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::StickyData",0,0)
  result = (Mezzanine::Physics::StickyData *)new Mezzanine::Physics::StickyData();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StickyData,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyData_StickyConstraints_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) 0 ;
  std::vector< Mezzanine::Physics::StickyConstraint * > *arg2 = (std::vector< Mezzanine::Physics::StickyConstraint * > *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::StickyConstraints",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyData::StickyConstraints",1,"Mezzanine::Physics::StickyData *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyData::StickyConstraints",2,"std::vector< Mezzanine::Physics::StickyConstraint * > *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyData,0))){
    SWIG_fail_ptr("StickyData_StickyConstraints_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyData);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t,0))){
    SWIG_fail_ptr("StickyData_StickyConstraints_set",2,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t);
  }
  
  if (arg1) (arg1)->StickyConstraints = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyData_StickyConstraints_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) 0 ;
  std::vector< Mezzanine::Physics::StickyConstraint * > *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::StickyConstraints",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyData::StickyConstraints",1,"Mezzanine::Physics::StickyData *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyData,0))){
    SWIG_fail_ptr("StickyData_StickyConstraints_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyData);
  }
  
  result = (std::vector< Mezzanine::Physics::StickyConstraint * > *)& ((arg1)->StickyConstraints);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyData_CreationQueue_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) 0 ;
  std::vector< Mezzanine::Physics::StickyConstraintConstructionInfo > *arg2 = (std::vector< Mezzanine::Physics::StickyConstraintConstructionInfo > *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::CreationQueue",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyData::CreationQueue",1,"Mezzanine::Physics::StickyData *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyData::CreationQueue",2,"std::vector< Mezzanine::Physics::StickyConstraintConstructionInfo > *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyData,0))){
    SWIG_fail_ptr("StickyData_CreationQueue_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyData);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t,0))){
    SWIG_fail_ptr("StickyData_CreationQueue_set",2,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t);
  }
  
  if (arg1) (arg1)->CreationQueue = *arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyData_CreationQueue_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) 0 ;
  std::vector< Mezzanine::Physics::StickyConstraintConstructionInfo > *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::CreationQueue",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyData::CreationQueue",1,"Mezzanine::Physics::StickyData *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyData,0))){
    SWIG_fail_ptr("StickyData_CreationQueue_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyData);
  }
  
  result = (std::vector< Mezzanine::Physics::StickyConstraintConstructionInfo > *)& ((arg1)->CreationQueue);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyData_MaxNumContacts_set(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) 0 ;
  Mezzanine::Whole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::MaxNumContacts",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyData::MaxNumContacts",1,"Mezzanine::Physics::StickyData *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::StickyData::MaxNumContacts",2,"Mezzanine::Whole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyData,0))){
    SWIG_fail_ptr("StickyData_MaxNumContacts_set",1,SWIGTYPE_p_Mezzanine__Physics__StickyData);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
  if (arg1) (arg1)->MaxNumContacts = arg2;
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StickyData_MaxNumContacts_get(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) 0 ;
  Mezzanine::Whole result;
  
  SWIG_check_num_args("Mezzanine::Physics::StickyData::MaxNumContacts",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StickyData::MaxNumContacts",1,"Mezzanine::Physics::StickyData *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StickyData,0))){
    SWIG_fail_ptr("StickyData_MaxNumContacts_get",1,SWIGTYPE_p_Mezzanine__Physics__StickyData);
  }
  
  result = (Mezzanine::Whole) ((arg1)->MaxNumContacts);
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_StickyData(void *obj) {
Mezzanine::Physics::StickyData *arg1 = (Mezzanine::Physics::StickyData *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_StickyData_methods[] = {
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_StickyData_attributes[] = {
    { "StickyConstraints", _wrap_StickyData_StickyConstraints_get, _wrap_StickyData_StickyConstraints_set},
    { "CreationQueue", _wrap_StickyData_CreationQueue_get, _wrap_StickyData_CreationQueue_set},
    { "MaxNumContacts", _wrap_StickyData_MaxNumContacts_get, _wrap_StickyData_MaxNumContacts_set},
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_StickyData_bases[] = {0};
static const char *swig_Mezzanine_Physics_StickyData_base_names[] = {0};
static swig_lua_class _wrap_class_Mezzanine_Physics_StickyData = { "StickyData", &SWIGTYPE_p_Mezzanine__Physics__StickyData,_wrap_new_StickyData, swig_delete_StickyData, swig_Mezzanine_Physics_StickyData_methods, swig_Mezzanine_Physics_StickyData_attributes, swig_Mezzanine_Physics_StickyData_bases, swig_Mezzanine_Physics_StickyData_base_names };

static int _wrap_new_RigidProxy__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real arg1 ;
  Mezzanine::Physics::PhysicsManager *arg2 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::RigidProxy",2,2)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",1,"Mezzanine::Real const");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",2,"Mezzanine::Physics::PhysicsManager *");
  arg1 = (Mezzanine::Real const)lua_tonumber(L, 1);
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_RigidProxy",2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)new Mezzanine::Physics::RigidProxy(arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RigidProxy__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real arg1 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  Mezzanine::Physics::PhysicsManager *arg3 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::RigidProxy",3,3)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",1,"Mezzanine::Real const");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",2,"Mezzanine::Physics::CollisionShape *");
  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",3,"Mezzanine::Physics::PhysicsManager *");
  arg1 = (Mezzanine::Real const)lua_tonumber(L, 1);
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("new_RigidProxy",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_RigidProxy",3,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)new Mezzanine::Physics::RigidProxy(arg1,arg2,arg3);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RigidProxy__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Physics::PhysicsManager *arg2 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::RigidProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::RigidProxy",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",1,"XML::Node const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RigidProxy",2,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_RigidProxy",1,SWIGTYPE_p_XML__Node);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_RigidProxy",2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::RigidProxy *)new Mezzanine::Physics::RigidProxy((XML::Node const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_RigidProxy(lua_State* L) {
  int argc;
  int argv[4]={
    1,2,3,4
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_RigidProxy__SWIG_2(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_RigidProxy__SWIG_0(L);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__CollisionShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          return _wrap_new_RigidProxy__SWIG_1(L);
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_RigidProxy'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::RigidProxy::RigidProxy(Mezzanine::Real const,Mezzanine::Physics::PhysicsManager *)\n"
    "    Mezzanine::Physics::RigidProxy::RigidProxy(Mezzanine::Real const,Mezzanine::Physics::CollisionShape *,Mezzanine::Physics::PhysicsManager *)\n"
    "    Mezzanine::Physics::RigidProxy::RigidProxy(XML::Node const &,Mezzanine::Physics::PhysicsManager *)\n");
  lua_error(L);return 0;
}


static int _wrap_RigidProxy_GetProxyType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::ProxyType result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetProxyType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetProxyType",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetProxyType",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (Mezzanine::ProxyType)((Mezzanine::Physics::RigidProxy const *)arg1)->GetProxyType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_AddToWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::AddToWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::AddToWorld",1,"Mezzanine::Physics::RigidProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_AddToWorld",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  (arg1)->AddToWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_RemoveFromWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::RemoveFromWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RemoveFromWorld",1,"Mezzanine::Physics::RigidProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_RemoveFromWorld",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  (arg1)->RemoveFromWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetCollisionShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetCollisionShape",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetCollisionShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetCollisionShape",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("RigidProxy_SetCollisionShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->SetCollisionShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetLinearMovementFactor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetLinearMovementFactor",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetLinearMovementFactor",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetLinearMovementFactor",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetLinearMovementFactor",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_SetLinearMovementFactor",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearMovementFactor((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetLinearMovementFactor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetLinearMovementFactor",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetLinearMovementFactor",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetLinearMovementFactor",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetLinearMovementFactor();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetAngularMovementFactor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetAngularMovementFactor",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetAngularMovementFactor",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetAngularMovementFactor",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetAngularMovementFactor",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_SetAngularMovementFactor",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularMovementFactor((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetAngularMovementFactor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetAngularMovementFactor",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetAngularMovementFactor",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetAngularMovementFactor",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetAngularMovementFactor();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetMass(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Real arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetMass",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetMass",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetMass",2,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetMass",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  (arg1)->SetMass(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetMass(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetMass",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetMass",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetMass",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::RigidProxy const *)arg1)->GetMass();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetDamping",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetDamping",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetDamping",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetDamping",3,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetDamping",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  (arg1)->SetDamping(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetLinearDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetLinearDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetLinearDamping",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetLinearDamping",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::RigidProxy const *)arg1)->GetLinearDamping();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetAngularDamping(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetAngularDamping",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetAngularDamping",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetAngularDamping",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::RigidProxy const *)arg1)->GetAngularDamping();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetLinearVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetLinearVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetLinearVelocity",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetLinearVelocity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetLinearVelocity",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_SetLinearVelocity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLinearVelocity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetLinearVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetLinearVelocity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetLinearVelocity",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetLinearVelocity",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetLinearVelocity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetAngularVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetAngularVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetAngularVelocity",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetAngularVelocity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetAngularVelocity",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_SetAngularVelocity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetAngularVelocity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetAngularVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetAngularVelocity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetAngularVelocity",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetAngularVelocity",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetAngularVelocity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_SetGravity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::SetGravity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetGravity",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::SetGravity",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_SetGravity",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_SetGravity",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetGravity((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetGravity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetGravity",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetGravity",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetGravity",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetGravity();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_ApplyForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::ApplyForce",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ApplyForce",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ApplyForce",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_ApplyForce",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_ApplyForce",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->ApplyForce((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetAppliedForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetAppliedForce",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetAppliedForce",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetAppliedForce",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetAppliedForce();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_ApplyTorque(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::ApplyTorque",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ApplyTorque",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ApplyTorque",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_ApplyTorque",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("RigidProxy_ApplyTorque",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->ApplyTorque((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetAppliedTorque(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetAppliedTorque",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetAppliedTorque",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetAppliedTorque",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetAppliedTorque();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_AddSyncObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::TransformableObject *arg2 = (Mezzanine::TransformableObject *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::AddSyncObject",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::AddSyncObject",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::AddSyncObject",2,"Mezzanine::TransformableObject *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_AddSyncObject",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("RigidProxy_AddSyncObject",2,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  (arg1)->AddSyncObject(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetSyncObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::UInt32 arg2 ;
  Mezzanine::TransformableObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetSyncObject",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetSyncObject",1,"Mezzanine::Physics::RigidProxy const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetSyncObject",2,"Mezzanine::UInt32 const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetSyncObject",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
  arg2 = (Mezzanine::UInt32 const)lua_tonumber(L, 2);
  result = (Mezzanine::TransformableObject *)((Mezzanine::Physics::RigidProxy const *)arg1)->GetSyncObject(arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__TransformableObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetNumSyncObjects(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::UInt32 result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetNumSyncObjects",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetNumSyncObjects",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetNumSyncObjects",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (Mezzanine::UInt32)((Mezzanine::Physics::RigidProxy const *)arg1)->GetNumSyncObjects();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_RemoveSyncObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::TransformableObject *arg2 = (Mezzanine::TransformableObject *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::RemoveSyncObject",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RemoveSyncObject",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RemoveSyncObject",2,"Mezzanine::TransformableObject *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_RemoveSyncObject",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__TransformableObject,0))){
    SWIG_fail_ptr("RigidProxy_RemoveSyncObject",2,SWIGTYPE_p_Mezzanine__TransformableObject);
  }
  
  (arg1)->RemoveSyncObject(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_RemoveAllSyncObjects(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::RemoveAllSyncObjects",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::RemoveAllSyncObjects",1,"Mezzanine::Physics::RigidProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_RemoveAllSyncObjects",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  (arg1)->RemoveAllSyncObjects();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_ProtoSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::ProtoSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ProtoSerializeProperties",1,"Mezzanine::Physics::RigidProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ProtoSerializeProperties",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_ProtoSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("RigidProxy_ProtoSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::RigidProxy const *)arg1)->ProtoSerializeProperties(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_ProtoDeSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::ProtoDeSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ProtoDeSerializeProperties",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::ProtoDeSerializeProperties",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_ProtoDeSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("RigidProxy_ProtoDeSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerializeProperties((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetDerivedSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetDerivedSerializableName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::GetDerivedSerializableName",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy_GetDerivedSerializableName",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = ((Mezzanine::Physics::RigidProxy const *)arg1)->GetDerivedSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy_GetSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::GetSerializableName",0,0)
  result = Mezzanine::Physics::RigidProxy::GetSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy__GetPhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  btRigidBody *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::_GetPhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::_GetPhysicsObject",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy__GetPhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (btRigidBody *)((Mezzanine::Physics::RigidProxy const *)arg1)->_GetPhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btRigidBody,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_RigidProxy__GetBasePhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  btCollisionObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::RigidProxy::_GetBasePhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::RigidProxy::_GetBasePhysicsObject",1,"Mezzanine::Physics::RigidProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("RigidProxy__GetBasePhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  result = (btCollisionObject *)((Mezzanine::Physics::RigidProxy const *)arg1)->_GetBasePhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCollisionObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_RigidProxy(void *obj) {
Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_RigidProxy_methods[] = {
    {"GetProxyType", _wrap_RigidProxy_GetProxyType}, 
    {"AddToWorld", _wrap_RigidProxy_AddToWorld}, 
    {"RemoveFromWorld", _wrap_RigidProxy_RemoveFromWorld}, 
    {"SetCollisionShape", _wrap_RigidProxy_SetCollisionShape}, 
    {"SetLinearMovementFactor", _wrap_RigidProxy_SetLinearMovementFactor}, 
    {"GetLinearMovementFactor", _wrap_RigidProxy_GetLinearMovementFactor}, 
    {"SetAngularMovementFactor", _wrap_RigidProxy_SetAngularMovementFactor}, 
    {"GetAngularMovementFactor", _wrap_RigidProxy_GetAngularMovementFactor}, 
    {"SetMass", _wrap_RigidProxy_SetMass}, 
    {"GetMass", _wrap_RigidProxy_GetMass}, 
    {"SetDamping", _wrap_RigidProxy_SetDamping}, 
    {"GetLinearDamping", _wrap_RigidProxy_GetLinearDamping}, 
    {"GetAngularDamping", _wrap_RigidProxy_GetAngularDamping}, 
    {"SetLinearVelocity", _wrap_RigidProxy_SetLinearVelocity}, 
    {"GetLinearVelocity", _wrap_RigidProxy_GetLinearVelocity}, 
    {"SetAngularVelocity", _wrap_RigidProxy_SetAngularVelocity}, 
    {"GetAngularVelocity", _wrap_RigidProxy_GetAngularVelocity}, 
    {"SetGravity", _wrap_RigidProxy_SetGravity}, 
    {"GetGravity", _wrap_RigidProxy_GetGravity}, 
    {"ApplyForce", _wrap_RigidProxy_ApplyForce}, 
    {"GetAppliedForce", _wrap_RigidProxy_GetAppliedForce}, 
    {"ApplyTorque", _wrap_RigidProxy_ApplyTorque}, 
    {"GetAppliedTorque", _wrap_RigidProxy_GetAppliedTorque}, 
    {"AddSyncObject", _wrap_RigidProxy_AddSyncObject}, 
    {"GetSyncObject", _wrap_RigidProxy_GetSyncObject}, 
    {"GetNumSyncObjects", _wrap_RigidProxy_GetNumSyncObjects}, 
    {"RemoveSyncObject", _wrap_RigidProxy_RemoveSyncObject}, 
    {"RemoveAllSyncObjects", _wrap_RigidProxy_RemoveAllSyncObjects}, 
    {"ProtoSerializeProperties", _wrap_RigidProxy_ProtoSerializeProperties}, 
    {"ProtoDeSerializeProperties", _wrap_RigidProxy_ProtoDeSerializeProperties}, 
    {"GetDerivedSerializableName", _wrap_RigidProxy_GetDerivedSerializableName}, 
    {"_GetPhysicsObject", _wrap_RigidProxy__GetPhysicsObject}, 
    {"_GetBasePhysicsObject", _wrap_RigidProxy__GetBasePhysicsObject}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_RigidProxy_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_RigidProxy_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_RigidProxy_base_names[] = {"Mezzanine::Physics::CollidableProxy *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_RigidProxy = { "RigidProxy", &SWIGTYPE_p_Mezzanine__Physics__RigidProxy,_wrap_new_RigidProxy, swig_delete_RigidProxy, swig_Mezzanine_Physics_RigidProxy_methods, swig_Mezzanine_Physics_RigidProxy_attributes, swig_Mezzanine_Physics_RigidProxy_bases, swig_Mezzanine_Physics_RigidProxy_base_names };

static int _wrap_new_SliderConstraint__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Quaternion *arg5 = 0 ;
  Mezzanine::Quaternion *arg6 = 0 ;
  Mezzanine::Boole arg7 ;
  Mezzanine::Physics::SliderConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SliderConstraint",7,7)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",5,"Mezzanine::Quaternion const &");
  if(!lua_isuserdata(L,6)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",6,"Mezzanine::Quaternion const &");
  if(!lua_isboolean(L,7)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",7,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_SliderConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_SliderConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_SliderConstraint",5,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_SliderConstraint",6,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg7 = (lua_toboolean(L, 7)!=0);
  result = (Mezzanine::Physics::SliderConstraint *)new Mezzanine::Physics::SliderConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Quaternion const &)*arg5,(Mezzanine::Quaternion const &)*arg6,arg7);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SliderConstraint__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Boole arg5 ;
  Mezzanine::Physics::SliderConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SliderConstraint",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",4,"Mezzanine::Transform const &");
  if(!lua_isboolean(L,5)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",5,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_SliderConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_SliderConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  arg5 = (lua_toboolean(L, 5)!=0);
  result = (Mezzanine::Physics::SliderConstraint *)new Mezzanine::Physics::SliderConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4,arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SliderConstraint__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Transform *arg3 = 0 ;
  Mezzanine::Transform *arg4 = 0 ;
  Mezzanine::Physics::SliderConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SliderConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",3,"Mezzanine::Transform const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",4,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_SliderConstraint",3,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("new_SliderConstraint",4,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  result = (Mezzanine::Physics::SliderConstraint *)new Mezzanine::Physics::SliderConstraint(arg1,arg2,(Mezzanine::Transform const &)*arg3,(Mezzanine::Transform const &)*arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SliderConstraint__SWIG_3(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  Mezzanine::Quaternion *arg3 = 0 ;
  Mezzanine::Boole arg4 ;
  Mezzanine::Physics::SliderConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SliderConstraint",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",2,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",3,"Mezzanine::Quaternion const &");
  if(!lua_isboolean(L,4)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SliderConstraint",4,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_SliderConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_SliderConstraint",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("new_SliderConstraint",3,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  arg4 = (lua_toboolean(L, 4)!=0);
  result = (Mezzanine::Physics::SliderConstraint *)new Mezzanine::Physics::SliderConstraint(arg1,(Mezzanine::Physics::Vector3 const &)*arg2,(Mezzanine::Quaternion const &)*arg3,arg4);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SliderConstraint(lua_State* L) {
  int argc;
  int argv[8]={
    1,2,3,4,5,6,7,8
  };
  
  argc = lua_gettop(L);
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            return _wrap_new_SliderConstraint__SWIG_2(L);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            _v = lua_isboolean(L,argv[3]);
          }
          if (_v) {
            return _wrap_new_SliderConstraint__SWIG_3(L);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Transform, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              _v = lua_isboolean(L,argv[4]);
            }
            if (_v) {
              return _wrap_new_SliderConstraint__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__RigidProxy, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        {
          void *ptr;
          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
            _v = 0;
          } else {
            _v = 1;
          }
        }
        if (_v) {
          {
            void *ptr;
            if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
              _v = 0;
            } else {
              _v = 1;
            }
          }
          if (_v) {
            {
              void *ptr;
              if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                _v = 0;
              } else {
                _v = 1;
              }
            }
            if (_v) {
              {
                void *ptr;
                if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
                  _v = 0;
                } else {
                  _v = 1;
                }
              }
              if (_v) {
                {
                  _v = lua_isboolean(L,argv[6]);
                }
                if (_v) {
                  return _wrap_new_SliderConstraint__SWIG_0(L);
                }
              }
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SliderConstraint'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::SliderConstraint::SliderConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Quaternion const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::SliderConstraint::SliderConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &,Mezzanine::Boole)\n"
    "    Mezzanine::Physics::SliderConstraint::SliderConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::RigidProxy *,Mezzanine::Transform const &,Mezzanine::Transform const &)\n"
    "    Mezzanine::Physics::SliderConstraint::SliderConstraint(Mezzanine::Physics::RigidProxy *,Mezzanine::Physics::Vector3 const &,Mezzanine::Quaternion const &,Mezzanine::Boole)\n");
  lua_error(L);return 0;
}


static int _wrap_SliderConstraint_SetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPivotATransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotATransform",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotATransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotATransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotATransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Transform *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPivotBTransform",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotBTransform",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotBTransform",2,"Mezzanine::Transform const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Transform,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotBTransform",2,SWIGTYPE_p_Mezzanine__Transform);
  }
  
  (arg1)->SetPivotBTransform((Mezzanine::Transform const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetPivotATransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetPivotATransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetPivotATransform",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetPivotATransform",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->GetPivotATransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetPivotBTransform(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Transform result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetPivotBTransform",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetPivotBTransform",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetPivotBTransform",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->GetPivotBTransform();
  {
    Mezzanine::Transform * resultptr = new Mezzanine::Transform((const Mezzanine::Transform &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Transform,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPivotALocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotALocation",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotALocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotALocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotALocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPivotBLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotBLocation",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotBLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotBLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetPivotBLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetPivotALocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetPivotALocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetPivotALocation",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetPivotALocation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->GetPivotALocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetPivotBLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetPivotBLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetPivotBLocation",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetPivotBLocation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->GetPivotBLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPivotARotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPivotARotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotARotation",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotARotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotARotation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotARotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetPivotARotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPivotBRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPivotBRotation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotBRotation",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPivotBRotation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotBRotation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("SliderConstraint_SetPivotBRotation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetPivotBRotation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetPivotARotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetPivotARotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetPivotARotation",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetPivotARotation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->GetPivotARotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetPivotBRotation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetPivotBRotation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetPivotBRotation",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetPivotBRotation",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->GetPivotBRotation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetUpperLinLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetUpperLinLimit",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetUpperLinLimit",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetUpperLinLimit",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetUpperLinLimit",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetUpperLinLimit((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetUpperAngLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetUpperAngLimit",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetUpperAngLimit",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetUpperAngLimit",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetUpperAngLimit",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetUpperAngLimit((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetLowerLinLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetLowerLinLimit",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetLowerLinLimit",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetLowerLinLimit",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetLowerLinLimit",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetLowerLinLimit((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetLowerAngLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetLowerAngLimit",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetLowerAngLimit",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetLowerAngLimit",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetLowerAngLimit",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetLowerAngLimit((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPoweredLinMotor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPoweredLinMotor",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPoweredLinMotor",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPoweredLinMotor",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPoweredLinMotor",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetPoweredLinMotor(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetTargetLinMotorVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetTargetLinMotorVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetTargetLinMotorVelocity",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetTargetLinMotorVelocity",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetTargetLinMotorVelocity",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetTargetLinMotorVelocity((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetMaxLinMotorForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetMaxLinMotorForce",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetMaxLinMotorForce",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetMaxLinMotorForce",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetMaxLinMotorForce",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetMaxLinMotorForce((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetPoweredAngMotor(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetPoweredAngMotor",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPoweredAngMotor",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetPoweredAngMotor",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetPoweredAngMotor",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetPoweredAngMotor(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetTargetAngMotorVelocity(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetTargetAngMotorVelocity",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetTargetAngMotorVelocity",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetTargetAngMotorVelocity",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetTargetAngMotorVelocity",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetTargetAngMotorVelocity((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetMaxAngMotorForce(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetMaxAngMotorForce",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetMaxAngMotorForce",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetMaxAngMotorForce",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetMaxAngMotorForce",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetMaxAngMotorForce((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetUseFrameOffset(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Boole arg2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetUseFrameOffset",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetUseFrameOffset",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetUseFrameOffset",2,"Mezzanine::Boole");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetUseFrameOffset",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  arg2 = (lua_toboolean(L, 2)!=0);
  (arg1)->SetUseFrameOffset(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetSoftnessDirLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetSoftnessDirLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessDirLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessDirLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetSoftnessDirLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSoftnessDirLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetRestitutionDirLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetRestitutionDirLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionDirLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionDirLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetRestitutionDirLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitutionDirLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetDampingDirLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetDampingDirLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingDirLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingDirLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetDampingDirLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetDampingDirLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetSoftnessDirAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetSoftnessDirAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessDirAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessDirAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetSoftnessDirAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSoftnessDirAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetRestitutionDirAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetRestitutionDirAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionDirAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionDirAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetRestitutionDirAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitutionDirAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetDampingDirAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetDampingDirAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingDirAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingDirAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetDampingDirAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetDampingDirAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetSoftnessLimLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetSoftnessLimLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessLimLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessLimLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetSoftnessLimLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSoftnessLimLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetRestitutionLimLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetRestitutionLimLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionLimLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionLimLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetRestitutionLimLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitutionLimLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetDampingLimLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetDampingLimLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingLimLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingLimLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetDampingLimLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetDampingLimLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetSoftnessLimAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetSoftnessLimAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessLimAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessLimAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetSoftnessLimAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSoftnessLimAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetRestitutionLimAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetRestitutionLimAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionLimAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionLimAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetRestitutionLimAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitutionLimAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetDampingLimAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetDampingLimAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingLimAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingLimAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetDampingLimAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetDampingLimAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetSoftnessOrthoLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetSoftnessOrthoLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessOrthoLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessOrthoLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetSoftnessOrthoLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSoftnessOrthoLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetRestitutionOrthoLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetRestitutionOrthoLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionOrthoLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionOrthoLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetRestitutionOrthoLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitutionOrthoLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetDampingOrthoLin(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetDampingOrthoLin",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingOrthoLin",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingOrthoLin",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetDampingOrthoLin",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetDampingOrthoLin((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetSoftnessOrthoAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetSoftnessOrthoAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessOrthoAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetSoftnessOrthoAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetSoftnessOrthoAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetSoftnessOrthoAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetRestitutionOrthoAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetRestitutionOrthoAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionOrthoAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetRestitutionOrthoAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetRestitutionOrthoAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetRestitutionOrthoAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_SetDampingOrthoAng(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::Real temp2 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::SetDampingOrthoAng",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingOrthoAng",1,"Mezzanine::Physics::SliderConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::SetDampingOrthoAng",2,"Mezzanine::Real const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_SetDampingOrthoAng",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  (arg1)->SetDampingOrthoAng((Mezzanine::Real const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_ValidParamOnAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::vector< enum Mezzanine::Physics::ConstraintParam > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::ValidParamOnAxis",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::ValidParamOnAxis",1,"Mezzanine::Physics::SliderConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::ValidParamOnAxis",2,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_ValidParamOnAxis",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  arg2 = (int)lua_tonumber(L, 2);
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->ValidParamOnAxis(arg2);
  {
    Mezzanine::Physics::Constraint::ParamList * resultptr = new Mezzanine::Physics::Constraint::ParamList((const Mezzanine::Physics::Constraint::ParamList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_ValidLinearAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::ValidLinearAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::ValidLinearAxis",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_ValidLinearAxis",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->ValidLinearAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_ValidAngularAxis(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  SwigValueWrapper< std::vector< int > > result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::ValidAngularAxis",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::ValidAngularAxis",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_ValidAngularAxis",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = ((Mezzanine::Physics::SliderConstraint const *)arg1)->ValidAngularAxis();
  {
    Mezzanine::Physics::Constraint::AxisList * resultptr = new Mezzanine::Physics::Constraint::AxisList((const Mezzanine::Physics::Constraint::AxisList &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_HasParamBeenSet(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  Mezzanine::Physics::ConstraintParam arg2 ;
  int arg3 ;
  Mezzanine::Boole result;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::HasParamBeenSet",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::HasParamBeenSet",1,"Mezzanine::Physics::SliderConstraint const *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::HasParamBeenSet",2,"Mezzanine::Physics::ConstraintParam");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::HasParamBeenSet",3,"int");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_HasParamBeenSet",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  arg2 = (Mezzanine::Physics::ConstraintParam)(int)lua_tonumber(L, 2);
  arg3 = (int)lua_tonumber(L, 3);
  result = (Mezzanine::Boole)((Mezzanine::Physics::SliderConstraint const *)arg1)->HasParamBeenSet(arg2,arg3);
  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SliderConstraint_GetConstraintBase(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) 0 ;
  btTypedConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SliderConstraint::GetConstraintBase",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SliderConstraint::GetConstraintBase",1,"Mezzanine::Physics::SliderConstraint const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,0))){
    SWIG_fail_ptr("SliderConstraint_GetConstraintBase",1,SWIGTYPE_p_Mezzanine__Physics__SliderConstraint);
  }
  
  result = (btTypedConstraint *)((Mezzanine::Physics::SliderConstraint const *)arg1)->GetConstraintBase();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btTypedConstraint,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SliderConstraint(void *obj) {
Mezzanine::Physics::SliderConstraint *arg1 = (Mezzanine::Physics::SliderConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_SliderConstraint_methods[] = {
    {"SetPivotATransform", _wrap_SliderConstraint_SetPivotATransform}, 
    {"SetPivotBTransform", _wrap_SliderConstraint_SetPivotBTransform}, 
    {"GetPivotATransform", _wrap_SliderConstraint_GetPivotATransform}, 
    {"GetPivotBTransform", _wrap_SliderConstraint_GetPivotBTransform}, 
    {"SetPivotALocation", _wrap_SliderConstraint_SetPivotALocation}, 
    {"SetPivotBLocation", _wrap_SliderConstraint_SetPivotBLocation}, 
    {"GetPivotALocation", _wrap_SliderConstraint_GetPivotALocation}, 
    {"GetPivotBLocation", _wrap_SliderConstraint_GetPivotBLocation}, 
    {"SetPivotARotation", _wrap_SliderConstraint_SetPivotARotation}, 
    {"SetPivotBRotation", _wrap_SliderConstraint_SetPivotBRotation}, 
    {"GetPivotARotation", _wrap_SliderConstraint_GetPivotARotation}, 
    {"GetPivotBRotation", _wrap_SliderConstraint_GetPivotBRotation}, 
    {"SetUpperLinLimit", _wrap_SliderConstraint_SetUpperLinLimit}, 
    {"SetUpperAngLimit", _wrap_SliderConstraint_SetUpperAngLimit}, 
    {"SetLowerLinLimit", _wrap_SliderConstraint_SetLowerLinLimit}, 
    {"SetLowerAngLimit", _wrap_SliderConstraint_SetLowerAngLimit}, 
    {"SetPoweredLinMotor", _wrap_SliderConstraint_SetPoweredLinMotor}, 
    {"SetTargetLinMotorVelocity", _wrap_SliderConstraint_SetTargetLinMotorVelocity}, 
    {"SetMaxLinMotorForce", _wrap_SliderConstraint_SetMaxLinMotorForce}, 
    {"SetPoweredAngMotor", _wrap_SliderConstraint_SetPoweredAngMotor}, 
    {"SetTargetAngMotorVelocity", _wrap_SliderConstraint_SetTargetAngMotorVelocity}, 
    {"SetMaxAngMotorForce", _wrap_SliderConstraint_SetMaxAngMotorForce}, 
    {"SetUseFrameOffset", _wrap_SliderConstraint_SetUseFrameOffset}, 
    {"SetSoftnessDirLin", _wrap_SliderConstraint_SetSoftnessDirLin}, 
    {"SetRestitutionDirLin", _wrap_SliderConstraint_SetRestitutionDirLin}, 
    {"SetDampingDirLin", _wrap_SliderConstraint_SetDampingDirLin}, 
    {"SetSoftnessDirAng", _wrap_SliderConstraint_SetSoftnessDirAng}, 
    {"SetRestitutionDirAng", _wrap_SliderConstraint_SetRestitutionDirAng}, 
    {"SetDampingDirAng", _wrap_SliderConstraint_SetDampingDirAng}, 
    {"SetSoftnessLimLin", _wrap_SliderConstraint_SetSoftnessLimLin}, 
    {"SetRestitutionLimLin", _wrap_SliderConstraint_SetRestitutionLimLin}, 
    {"SetDampingLimLin", _wrap_SliderConstraint_SetDampingLimLin}, 
    {"SetSoftnessLimAng", _wrap_SliderConstraint_SetSoftnessLimAng}, 
    {"SetRestitutionLimAng", _wrap_SliderConstraint_SetRestitutionLimAng}, 
    {"SetDampingLimAng", _wrap_SliderConstraint_SetDampingLimAng}, 
    {"SetSoftnessOrthoLin", _wrap_SliderConstraint_SetSoftnessOrthoLin}, 
    {"SetRestitutionOrthoLin", _wrap_SliderConstraint_SetRestitutionOrthoLin}, 
    {"SetDampingOrthoLin", _wrap_SliderConstraint_SetDampingOrthoLin}, 
    {"SetSoftnessOrthoAng", _wrap_SliderConstraint_SetSoftnessOrthoAng}, 
    {"SetRestitutionOrthoAng", _wrap_SliderConstraint_SetRestitutionOrthoAng}, 
    {"SetDampingOrthoAng", _wrap_SliderConstraint_SetDampingOrthoAng}, 
    {"ValidParamOnAxis", _wrap_SliderConstraint_ValidParamOnAxis}, 
    {"ValidLinearAxis", _wrap_SliderConstraint_ValidLinearAxis}, 
    {"ValidAngularAxis", _wrap_SliderConstraint_ValidAngularAxis}, 
    {"HasParamBeenSet", _wrap_SliderConstraint_HasParamBeenSet}, 
    {"GetConstraintBase", _wrap_SliderConstraint_GetConstraintBase}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_SliderConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_SliderConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_SliderConstraint_base_names[] = {"Mezzanine::Physics::DualTransformConstraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_SliderConstraint = { "SliderConstraint", &SWIGTYPE_p_Mezzanine__Physics__SliderConstraint,_wrap_new_SliderConstraint, swig_delete_SliderConstraint, swig_Mezzanine_Physics_SliderConstraint_methods, swig_Mezzanine_Physics_SliderConstraint_attributes, swig_Mezzanine_Physics_SliderConstraint_bases, swig_Mezzanine_Physics_SliderConstraint_base_names };

static int _wrap_new_SoftCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btSoftBodyCollisionShape *arg2 = (btSoftBodyCollisionShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::SoftCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftCollisionShape::SoftCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftCollisionShape::SoftCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftCollisionShape::SoftCollisionShape",2,"btSoftBodyCollisionShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btSoftBodyCollisionShape,0))){
    SWIG_fail_ptr("new_SoftCollisionShape",2,SWIGTYPE_p_btSoftBodyCollisionShape);
  }
  
  result = (Mezzanine::Physics::SoftCollisionShape *)new Mezzanine::Physics::SoftCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SoftCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftCollisionShape *arg1 = (Mezzanine::Physics::SoftCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftCollisionShape::GetType",1,"Mezzanine::Physics::SoftCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftCollisionShape,0))){
    SWIG_fail_ptr("SoftCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__SoftCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::SoftCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SoftCollisionShape(void *obj) {
Mezzanine::Physics::SoftCollisionShape *arg1 = (Mezzanine::Physics::SoftCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_SoftCollisionShape_methods[] = {
    {"GetType", _wrap_SoftCollisionShape_GetType}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_SoftCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_SoftCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_SoftCollisionShape_base_names[] = {"Mezzanine::Physics::MeshCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_SoftCollisionShape = { "SoftCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__SoftCollisionShape,_wrap_new_SoftCollisionShape, swig_delete_SoftCollisionShape, swig_Mezzanine_Physics_SoftCollisionShape_methods, swig_Mezzanine_Physics_SoftCollisionShape_attributes, swig_Mezzanine_Physics_SoftCollisionShape_bases, swig_Mezzanine_Physics_SoftCollisionShape_base_names };

static int _wrap_new_SoftProxy__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Real arg1 ;
  Mezzanine::Physics::PhysicsManager *arg2 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::SoftProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SoftProxy",2,2)
  if(!lua_isnumber(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SoftProxy",1,"Mezzanine::Real const");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SoftProxy",2,"Mezzanine::Physics::PhysicsManager *");
  arg1 = (Mezzanine::Real const)lua_tonumber(L, 1);
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_SoftProxy",2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::SoftProxy *)new Mezzanine::Physics::SoftProxy(arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SoftProxy__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node *arg1 = 0 ;
  Mezzanine::Physics::PhysicsManager *arg2 = (Mezzanine::Physics::PhysicsManager *) 0 ;
  Mezzanine::Physics::SoftProxy *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SoftProxy",2,2)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SoftProxy",1,"XML::Node const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SoftProxy",2,"Mezzanine::Physics::PhysicsManager *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_SoftProxy",1,SWIGTYPE_p_XML__Node);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager,0))){
    SWIG_fail_ptr("new_SoftProxy",2,SWIGTYPE_p_Mezzanine__Physics__PhysicsManager);
  }
  
  result = (Mezzanine::Physics::SoftProxy *)new Mezzanine::Physics::SoftProxy((XML::Node const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SoftProxy(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_SoftProxy__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isnumber(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__PhysicsManager, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_SoftProxy__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SoftProxy'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::SoftProxy::SoftProxy(Mezzanine::Real const,Mezzanine::Physics::PhysicsManager *)\n"
    "    Mezzanine::Physics::SoftProxy::SoftProxy(XML::Node const &,Mezzanine::Physics::PhysicsManager *)\n");
  lua_error(L);return 0;
}


static int _wrap_SoftProxy_GetProxyType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::ProxyType result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::GetProxyType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::GetProxyType",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_GetProxyType",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = (Mezzanine::ProxyType)((Mezzanine::Physics::SoftProxy const *)arg1)->GetProxyType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_AddToWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::AddToWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::AddToWorld",1,"Mezzanine::Physics::SoftProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_AddToWorld",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  (arg1)->AddToWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_RemoveFromWorld(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::RemoveFromWorld",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::RemoveFromWorld",1,"Mezzanine::Physics::SoftProxy *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_RemoveFromWorld",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  (arg1)->RemoveFromWorld();
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Physics::CollisionShape *arg2 = (Mezzanine::Physics::CollisionShape *) 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetCollisionShape",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetCollisionShape",1,"Mezzanine::Physics::SoftProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetCollisionShape",2,"Mezzanine::Physics::CollisionShape *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetCollisionShape",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape,0))){
    SWIG_fail_ptr("SoftProxy_SetCollisionShape",2,SWIGTYPE_p_Mezzanine__Physics__CollisionShape);
  }
  
  (arg1)->SetCollisionShape(arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetLocation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetLocation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetLocation",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetLocation",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetLocation",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("SoftProxy_SetLocation",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetLocation((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetLocation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetLocation",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetLocation",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetLocation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetLocation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetLocation",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetLocation",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetLocation(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetLocation(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__SoftProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_SoftProxy_SetLocation__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__SoftProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_SoftProxy_SetLocation__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'SoftProxy_SetLocation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::SoftProxy::SetLocation(Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::SoftProxy::SetLocation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_SoftProxy_GetLocation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::GetLocation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::GetLocation",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_GetLocation",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = ((Mezzanine::Physics::SoftProxy const *)arg1)->GetLocation();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetOrientation__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Quaternion *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetOrientation",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",2,"Mezzanine::Quaternion const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetOrientation",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Quaternion,0))){
    SWIG_fail_ptr("SoftProxy_SetOrientation",2,SWIGTYPE_p_Mezzanine__Quaternion);
  }
  
  (arg1)->SetOrientation((Mezzanine::Quaternion const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetOrientation__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  Mezzanine::Real arg5 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetOrientation",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",4,"Mezzanine::Real const");
  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetOrientation",5,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetOrientation",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  arg5 = (Mezzanine::Real const)lua_tonumber(L, 5);
  (arg1)->SetOrientation(arg2,arg3,arg4,arg5);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetOrientation(lua_State* L) {
  int argc;
  int argv[6]={
    1,2,3,4,5,6
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__SoftProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Quaternion, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_SoftProxy_SetOrientation__SWIG_0(L);
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__SoftProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            {
              _v = lua_isnumber(L,argv[4]);
            }
            if (_v) {
              return _wrap_SoftProxy_SetOrientation__SWIG_1(L);
            }
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'SoftProxy_SetOrientation'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::SoftProxy::SetOrientation(Mezzanine::Quaternion const &)\n"
    "    Mezzanine::Physics::SoftProxy::SetOrientation(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_SoftProxy_GetOrientation(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Quaternion result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::GetOrientation",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::GetOrientation",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_GetOrientation",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = ((Mezzanine::Physics::SoftProxy const *)arg1)->GetOrientation();
  {
    Mezzanine::Quaternion * resultptr = new Mezzanine::Quaternion((const Mezzanine::Quaternion &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Quaternion,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetScale__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetScale",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetScale",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetScale",2,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetScale",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("SoftProxy_SetScale",2,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  (arg1)->SetScale((Mezzanine::Physics::Vector3 const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetScale__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  Mezzanine::Real arg4 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::SetScale",4,4)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetScale",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetScale",2,"Mezzanine::Real const");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetScale",3,"Mezzanine::Real const");
  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::SetScale",4,"Mezzanine::Real const");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_SetScale",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  arg2 = (Mezzanine::Real const)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real const)lua_tonumber(L, 3);
  arg4 = (Mezzanine::Real const)lua_tonumber(L, 4);
  (arg1)->SetScale(arg2,arg3,arg4);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_SetScale(lua_State* L) {
  int argc;
  int argv[5]={
    1,2,3,4,5
  };
  
  argc = lua_gettop(L);
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__SoftProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        void *ptr;
        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__Vector3, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_SoftProxy_SetScale__SWIG_0(L);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__Physics__SoftProxy, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        {
          _v = lua_isnumber(L,argv[2]);
        }
        if (_v) {
          {
            _v = lua_isnumber(L,argv[3]);
          }
          if (_v) {
            return _wrap_SoftProxy_SetScale__SWIG_1(L);
          }
        }
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'SoftProxy_SetScale'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::SoftProxy::SetScale(Mezzanine::Physics::Vector3 const &)\n"
    "    Mezzanine::Physics::SoftProxy::SetScale(Mezzanine::Real const,Mezzanine::Real const,Mezzanine::Real const)\n");
  lua_error(L);return 0;
}


static int _wrap_SoftProxy_GetScale(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::Physics::Vector3 result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::GetScale",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::GetScale",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_GetScale",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = ((Mezzanine::Physics::SoftProxy const *)arg1)->GetScale();
  {
    Mezzanine::Physics::Vector3 * resultptr = new Mezzanine::Physics::Vector3((const Mezzanine::Physics::Vector3 &) result);
    SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__Vector3,1); SWIG_arg++;
  }
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoSerialize",1,"Mezzanine::Physics::SoftProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SoftProxy_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::SoftProxy const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_ProtoSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::ProtoSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoSerializeProperties",1,"Mezzanine::Physics::SoftProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoSerializeProperties",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_ProtoSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SoftProxy_ProtoSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::SoftProxy const *)arg1)->ProtoSerializeProperties(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_ProtoSeriailzeNodes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::ProtoSeriailzeNodes",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoSeriailzeNodes",1,"Mezzanine::Physics::SoftProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoSeriailzeNodes",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_ProtoSeriailzeNodes",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SoftProxy_ProtoSeriailzeNodes",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::SoftProxy const *)arg1)->ProtoSeriailzeNodes(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoDeSerialize",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SoftProxy_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_ProtoDeSerializeProperties(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::ProtoDeSerializeProperties",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoDeSerializeProperties",1,"Mezzanine::Physics::SoftProxy *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoDeSerializeProperties",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_ProtoDeSerializeProperties",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SoftProxy_ProtoDeSerializeProperties",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerializeProperties((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_ProtoDeSeriailzeNodes(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::ProtoDeSeriailzeNodes",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoDeSeriailzeNodes",1,"Mezzanine::Physics::SoftProxy const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::ProtoDeSeriailzeNodes",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_ProtoDeSeriailzeNodes",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SoftProxy_ProtoDeSeriailzeNodes",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::SoftProxy const *)arg1)->ProtoDeSeriailzeNodes(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_GetDerivedSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::GetDerivedSerializableName",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::GetDerivedSerializableName",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy_GetDerivedSerializableName",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = ((Mezzanine::Physics::SoftProxy const *)arg1)->GetDerivedSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy_GetSerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::GetSerializableName",0,0)
  result = Mezzanine::Physics::SoftProxy::GetSerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy__GetPhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  btSoftBody *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::_GetPhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::_GetPhysicsObject",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy__GetPhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = (btSoftBody *)((Mezzanine::Physics::SoftProxy const *)arg1)->_GetPhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btSoftBody,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SoftProxy__GetBasePhysicsObject(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) 0 ;
  btCollisionObject *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SoftProxy::_GetBasePhysicsObject",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SoftProxy::_GetBasePhysicsObject",1,"Mezzanine::Physics::SoftProxy const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy,0))){
    SWIG_fail_ptr("SoftProxy__GetBasePhysicsObject",1,SWIGTYPE_p_Mezzanine__Physics__SoftProxy);
  }
  
  result = (btCollisionObject *)((Mezzanine::Physics::SoftProxy const *)arg1)->_GetBasePhysicsObject();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btCollisionObject,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SoftProxy(void *obj) {
Mezzanine::Physics::SoftProxy *arg1 = (Mezzanine::Physics::SoftProxy *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_SoftProxy_methods[] = {
    {"GetProxyType", _wrap_SoftProxy_GetProxyType}, 
    {"AddToWorld", _wrap_SoftProxy_AddToWorld}, 
    {"RemoveFromWorld", _wrap_SoftProxy_RemoveFromWorld}, 
    {"SetCollisionShape", _wrap_SoftProxy_SetCollisionShape}, 
    {"SetLocation", _wrap_SoftProxy_SetLocation}, 
    {"GetLocation", _wrap_SoftProxy_GetLocation}, 
    {"SetOrientation", _wrap_SoftProxy_SetOrientation}, 
    {"GetOrientation", _wrap_SoftProxy_GetOrientation}, 
    {"SetScale", _wrap_SoftProxy_SetScale}, 
    {"GetScale", _wrap_SoftProxy_GetScale}, 
    {"ProtoSerialize", _wrap_SoftProxy_ProtoSerialize}, 
    {"ProtoSerializeProperties", _wrap_SoftProxy_ProtoSerializeProperties}, 
    {"ProtoSeriailzeNodes", _wrap_SoftProxy_ProtoSeriailzeNodes}, 
    {"ProtoDeSerialize", _wrap_SoftProxy_ProtoDeSerialize}, 
    {"ProtoDeSerializeProperties", _wrap_SoftProxy_ProtoDeSerializeProperties}, 
    {"ProtoDeSeriailzeNodes", _wrap_SoftProxy_ProtoDeSeriailzeNodes}, 
    {"GetDerivedSerializableName", _wrap_SoftProxy_GetDerivedSerializableName}, 
    {"_GetPhysicsObject", _wrap_SoftProxy__GetPhysicsObject}, 
    {"_GetBasePhysicsObject", _wrap_SoftProxy__GetBasePhysicsObject}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_SoftProxy_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_SoftProxy_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_SoftProxy_base_names[] = {"Mezzanine::Physics::CollidableProxy *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_SoftProxy = { "SoftProxy", &SWIGTYPE_p_Mezzanine__Physics__SoftProxy,_wrap_new_SoftProxy, swig_delete_SoftProxy, swig_Mezzanine_Physics_SoftProxy_methods, swig_Mezzanine_Physics_SoftProxy_attributes, swig_Mezzanine_Physics_SoftProxy_bases, swig_Mezzanine_Physics_SoftProxy_base_names };

static int _wrap_new_SphereCollisionShape__SWIG_0(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  Mezzanine::Real *arg2 = 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Real temp2 ;
  Mezzanine::Physics::SphereCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",1,"Mezzanine::String const &");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",2,"Mezzanine::Real const &");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  temp2=(Mezzanine::Real)lua_tonumber(L,2); arg2=&temp2;
  result = (Mezzanine::Physics::SphereCollisionShape *)new Mezzanine::Physics::SphereCollisionShape((Mezzanine::String const &)*arg1,(Mezzanine::Real const &)*arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SphereCollisionShape__SWIG_1(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btSphereShape *arg2 = (btSphereShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::SphereCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",2,"btSphereShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btSphereShape,0))){
    SWIG_fail_ptr("new_SphereCollisionShape",2,SWIGTYPE_p_btSphereShape);
  }
  
  result = (Mezzanine::Physics::SphereCollisionShape *)new Mezzanine::Physics::SphereCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SphereCollisionShape__SWIG_2(lua_State* L) {
  int SWIG_arg = 0;
  XML::Node arg1 ;
  XML::Node *argp1 ;
  Mezzanine::Physics::SphereCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",1,1)
  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape",1,"XML::Node");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("new_SphereCollisionShape",1,SWIGTYPE_p_XML__Node);
  }
  arg1 = *argp1;
  
  result = (Mezzanine::Physics::SphereCollisionShape *)new Mezzanine::Physics::SphereCollisionShape(arg1);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_new_SphereCollisionShape(lua_State* L) {
  int argc;
  int argv[3]={
    1,2,3
  };
  
  argc = lua_gettop(L);
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_XML__Node, 0)) {
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      return _wrap_new_SphereCollisionShape__SWIG_2(L);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        void *ptr;
        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_btSphereShape, 0)) {
          _v = 0;
        } else {
          _v = 1;
        }
      }
      if (_v) {
        return _wrap_new_SphereCollisionShape__SWIG_1(L);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = lua_isstring(L,argv[0]);
    }
    if (_v) {
      {
        _v = lua_isnumber(L,argv[1]);
      }
      if (_v) {
        return _wrap_new_SphereCollisionShape__SWIG_0(L);
      }
    }
  }
  
  lua_pushstring(L,"Wrong arguments for overloaded function 'new_SphereCollisionShape'\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape(Mezzanine::String const &,Mezzanine::Real const &)\n"
    "    Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape(Mezzanine::String const &,btSphereShape *)\n"
    "    Mezzanine::Physics::SphereCollisionShape::SphereCollisionShape(XML::Node)\n");
  lua_error(L);return 0;
}


static int _wrap_SphereCollisionShape_GetRadius(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SphereCollisionShape *arg1 = (Mezzanine::Physics::SphereCollisionShape *) 0 ;
  Mezzanine::Real result;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::GetRadius",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::GetRadius",1,"Mezzanine::Physics::SphereCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,0))){
    SWIG_fail_ptr("SphereCollisionShape_GetRadius",1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape);
  }
  
  result = (Mezzanine::Real)((Mezzanine::Physics::SphereCollisionShape const *)arg1)->GetRadius();
  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SphereCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SphereCollisionShape *arg1 = (Mezzanine::Physics::SphereCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::GetType",1,"Mezzanine::Physics::SphereCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,0))){
    SWIG_fail_ptr("SphereCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::SphereCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SphereCollisionShape_GetSphereShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SphereCollisionShape *arg1 = (Mezzanine::Physics::SphereCollisionShape *) 0 ;
  btSphereShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::GetSphereShape",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::GetSphereShape",1,"Mezzanine::Physics::SphereCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,0))){
    SWIG_fail_ptr("SphereCollisionShape_GetSphereShape",1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape);
  }
  
  result = (btSphereShape *)((Mezzanine::Physics::SphereCollisionShape const *)arg1)->GetSphereShape();
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_btSphereShape,0); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SphereCollisionShape_ProtoSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SphereCollisionShape *arg1 = (Mezzanine::Physics::SphereCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::ProtoSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::ProtoSerialize",1,"Mezzanine::Physics::SphereCollisionShape const *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::ProtoSerialize",2,"XML::Node &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,0))){
    SWIG_fail_ptr("SphereCollisionShape_ProtoSerialize",1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SphereCollisionShape_ProtoSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  ((Mezzanine::Physics::SphereCollisionShape const *)arg1)->ProtoSerialize(*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SphereCollisionShape_ProtoDeSerialize(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::SphereCollisionShape *arg1 = (Mezzanine::Physics::SphereCollisionShape *) 0 ;
  XML::Node *arg2 = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::ProtoDeSerialize",2,2)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::ProtoDeSerialize",1,"Mezzanine::Physics::SphereCollisionShape *");
  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::Physics::SphereCollisionShape::ProtoDeSerialize",2,"XML::Node const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,0))){
    SWIG_fail_ptr("SphereCollisionShape_ProtoDeSerialize",1,SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XML__Node,0))){
    SWIG_fail_ptr("SphereCollisionShape_ProtoDeSerialize",2,SWIGTYPE_p_XML__Node);
  }
  
  (arg1)->ProtoDeSerialize((XML::Node const &)*arg2);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_SphereCollisionShape_SerializableName(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String result;
  
  SWIG_check_num_args("Mezzanine::Physics::SphereCollisionShape::SerializableName",0,0)
  result = Mezzanine::Physics::SphereCollisionShape::SerializableName();
  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_SphereCollisionShape(void *obj) {
Mezzanine::Physics::SphereCollisionShape *arg1 = (Mezzanine::Physics::SphereCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_SphereCollisionShape_methods[] = {
    {"GetRadius", _wrap_SphereCollisionShape_GetRadius}, 
    {"GetType", _wrap_SphereCollisionShape_GetType}, 
    {"GetSphereShape", _wrap_SphereCollisionShape_GetSphereShape}, 
    {"ProtoSerialize", _wrap_SphereCollisionShape_ProtoSerialize}, 
    {"ProtoDeSerialize", _wrap_SphereCollisionShape_ProtoDeSerialize}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_SphereCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_SphereCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_SphereCollisionShape_base_names[] = {"Mezzanine::Physics::PrimitiveCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_SphereCollisionShape = { "SphereCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__SphereCollisionShape,_wrap_new_SphereCollisionShape, swig_delete_SphereCollisionShape, swig_Mezzanine_Physics_SphereCollisionShape_methods, swig_Mezzanine_Physics_SphereCollisionShape_attributes, swig_Mezzanine_Physics_SphereCollisionShape_bases, swig_Mezzanine_Physics_SphereCollisionShape_base_names };

static int _wrap_new_StaticMeshCollisionShape(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::String *arg1 = 0 ;
  btBvhTriangleMeshShape *arg2 = (btBvhTriangleMeshShape *) 0 ;
  Mezzanine::String temp1 ;
  Mezzanine::Physics::StaticMeshCollisionShape *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::StaticMeshCollisionShape::StaticMeshCollisionShape",2,2)
  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::Physics::StaticMeshCollisionShape::StaticMeshCollisionShape",1,"Mezzanine::String const &");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::StaticMeshCollisionShape::StaticMeshCollisionShape",2,"btBvhTriangleMeshShape *");
  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_btBvhTriangleMeshShape,0))){
    SWIG_fail_ptr("new_StaticMeshCollisionShape",2,SWIGTYPE_p_btBvhTriangleMeshShape);
  }
  
  result = (Mezzanine::Physics::StaticMeshCollisionShape *)new Mezzanine::Physics::StaticMeshCollisionShape((Mezzanine::String const &)*arg1,arg2);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_StaticMeshCollisionShape_GetType(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::StaticMeshCollisionShape *arg1 = (Mezzanine::Physics::StaticMeshCollisionShape *) 0 ;
  Mezzanine::Physics::CollisionShape::ShapeType result;
  
  SWIG_check_num_args("Mezzanine::Physics::StaticMeshCollisionShape::GetType",1,1)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::StaticMeshCollisionShape::GetType",1,"Mezzanine::Physics::StaticMeshCollisionShape const *");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,0))){
    SWIG_fail_ptr("StaticMeshCollisionShape_GetType",1,SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape);
  }
  
  result = (Mezzanine::Physics::CollisionShape::ShapeType)((Mezzanine::Physics::StaticMeshCollisionShape const *)arg1)->GetType();
  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_StaticMeshCollisionShape(void *obj) {
Mezzanine::Physics::StaticMeshCollisionShape *arg1 = (Mezzanine::Physics::StaticMeshCollisionShape *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_StaticMeshCollisionShape_methods[] = {
    {"GetType", _wrap_StaticMeshCollisionShape_GetType}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_StaticMeshCollisionShape_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_StaticMeshCollisionShape_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_StaticMeshCollisionShape_base_names[] = {"Mezzanine::Physics::MeshCollisionShape *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_StaticMeshCollisionShape = { "StaticMeshCollisionShape", &SWIGTYPE_p_Mezzanine__Physics__StaticMeshCollisionShape,_wrap_new_StaticMeshCollisionShape, swig_delete_StaticMeshCollisionShape, swig_Mezzanine_Physics_StaticMeshCollisionShape_methods, swig_Mezzanine_Physics_StaticMeshCollisionShape_attributes, swig_Mezzanine_Physics_StaticMeshCollisionShape_bases, swig_Mezzanine_Physics_StaticMeshCollisionShape_base_names };

static int _wrap_new_UniversalConstraint(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::RigidProxy *arg1 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::RigidProxy *arg2 = (Mezzanine::Physics::RigidProxy *) 0 ;
  Mezzanine::Physics::Vector3 *arg3 = 0 ;
  Mezzanine::Physics::Vector3 *arg4 = 0 ;
  Mezzanine::Physics::Vector3 *arg5 = 0 ;
  Mezzanine::Physics::UniversalConstraint *result = 0 ;
  
  SWIG_check_num_args("Mezzanine::Physics::UniversalConstraint::UniversalConstraint",5,5)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::UniversalConstraint",1,"Mezzanine::Physics::RigidProxy *");
  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::UniversalConstraint",2,"Mezzanine::Physics::RigidProxy *");
  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::UniversalConstraint",3,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::UniversalConstraint",4,"Mezzanine::Physics::Vector3 const &");
  if(!lua_isuserdata(L,5)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::UniversalConstraint",5,"Mezzanine::Physics::Vector3 const &");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_UniversalConstraint",1,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy,0))){
    SWIG_fail_ptr("new_UniversalConstraint",2,SWIGTYPE_p_Mezzanine__Physics__RigidProxy);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_UniversalConstraint",3,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_UniversalConstraint",4,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_Mezzanine__Vector3,0))){
    SWIG_fail_ptr("new_UniversalConstraint",5,SWIGTYPE_p_Mezzanine__Vector3);
  }
  
  result = (Mezzanine::Physics::UniversalConstraint *)new Mezzanine::Physics::UniversalConstraint(arg1,arg2,(Mezzanine::Physics::Vector3 const &)*arg3,(Mezzanine::Physics::Vector3 const &)*arg4,(Mezzanine::Physics::Vector3 const &)*arg5);
  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint,1); SWIG_arg++; 
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_UniversalConstraint_SetUpperLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::UniversalConstraint *arg1 = (Mezzanine::Physics::UniversalConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::UniversalConstraint::SetUpperLimit",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::SetUpperLimit",1,"Mezzanine::Physics::UniversalConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::SetUpperLimit",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::SetUpperLimit",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint,0))){
    SWIG_fail_ptr("UniversalConstraint_SetUpperLimit",1,SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetUpperLimit(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static int _wrap_UniversalConstraint_SetLowerLimit(lua_State* L) {
  int SWIG_arg = 0;
  Mezzanine::Physics::UniversalConstraint *arg1 = (Mezzanine::Physics::UniversalConstraint *) 0 ;
  Mezzanine::Real arg2 ;
  Mezzanine::Real arg3 ;
  
  SWIG_check_num_args("Mezzanine::Physics::UniversalConstraint::SetLowerLimit",3,3)
  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::SetLowerLimit",1,"Mezzanine::Physics::UniversalConstraint *");
  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::SetLowerLimit",2,"Mezzanine::Real");
  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::Physics::UniversalConstraint::SetLowerLimit",3,"Mezzanine::Real");
  
  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint,0))){
    SWIG_fail_ptr("UniversalConstraint_SetLowerLimit",1,SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint);
  }
  
  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
  arg3 = (Mezzanine::Real)lua_tonumber(L, 3);
  (arg1)->SetLowerLimit(arg2,arg3);
  
  return SWIG_arg;
  
  if(0) SWIG_fail;
  
fail:
  lua_error(L);
  return SWIG_arg;
}


static void swig_delete_UniversalConstraint(void *obj) {
Mezzanine::Physics::UniversalConstraint *arg1 = (Mezzanine::Physics::UniversalConstraint *) obj;
delete arg1;
}
static swig_lua_method swig_Mezzanine_Physics_UniversalConstraint_methods[] = {
    {"SetUpperLimit", _wrap_UniversalConstraint_SetUpperLimit}, 
    {"SetLowerLimit", _wrap_UniversalConstraint_SetLowerLimit}, 
    {0,0}
};
static swig_lua_attribute swig_Mezzanine_Physics_UniversalConstraint_attributes[] = {
    {0,0,0}
};
static swig_lua_class *swig_Mezzanine_Physics_UniversalConstraint_bases[] = {0,0};
static const char *swig_Mezzanine_Physics_UniversalConstraint_base_names[] = {"Mezzanine::Physics::Generic6DofConstraint *",0};
static swig_lua_class _wrap_class_Mezzanine_Physics_UniversalConstraint = { "UniversalConstraint", &SWIGTYPE_p_Mezzanine__Physics__UniversalConstraint,_wrap_new_UniversalConstraint, swig_delete_UniversalConstraint, swig_Mezzanine_Physics_UniversalConstraint_methods, swig_Mezzanine_Physics_UniversalConstraint_attributes, swig_Mezzanine_Physics_UniversalConstraint_bases, swig_Mezzanine_Physics_UniversalConstraint_base_names };

#ifdef __cplusplus
}
#endif

static const struct luaL_Reg swig_commands[] = {
    { "CollisionShape_SerializableName", _wrap_CollisionShape_SerializableName},
    { "CreateShape",_wrap_CreateShape},
    { "InternalShapeTypeToShapeType", _wrap_InternalShapeTypeToShapeType},
    { "ShapeTypeToString", _wrap_ShapeTypeToString},
    { "StringToShapeType", _wrap_StringToShapeType},
    { "SingletonCollisionShapeManager_GetSingletonPtr", _wrap_SingletonCollisionShapeManager_GetSingletonPtr},
    { "SingletonCollisionShapeManager_SingletonValid", _wrap_SingletonCollisionShapeManager_SingletonValid},
    { "PrimitiveCollisionShape_SerializableName", _wrap_PrimitiveCollisionShape_SerializableName},
    { "BoxCollisionShape_SerializableName", _wrap_BoxCollisionShape_SerializableName},
    { "CapsuleCollisionShape_SerializableName", _wrap_CapsuleCollisionShape_SerializableName},
    { "SerializeError",_wrap_SerializeError},
    { "DeSerializeError",_wrap_DeSerializeError},
    { "Vector3_Unit_X", _wrap_Vector3_Unit_X},
    { "Vector3_Unit_Y", _wrap_Vector3_Unit_Y},
    { "Vector3_Unit_Z", _wrap_Vector3_Unit_Z},
    { "Vector3_Neg_Unit_X", _wrap_Vector3_Neg_Unit_X},
    { "Vector3_Neg_Unit_Y", _wrap_Vector3_Neg_Unit_Y},
    { "Vector3_Neg_Unit_Z", _wrap_Vector3_Neg_Unit_Z},
    { "Vector3_UnitOnAxis", _wrap_Vector3_UnitOnAxis},
    { "Vector3_SerializableName", _wrap_Vector3_SerializableName},
    { "__add",_wrap___add},
    { "__sub",_wrap___sub},
    { "__mul",_wrap___mul},
    { "__div",_wrap___div},
    { "Quaternion_SerializableName", _wrap_Quaternion_SerializableName},
    { "WorldProxy_GetSerializableName", _wrap_WorldProxy_GetSerializableName},
    { "CollidableProxy_GetSerializableName", _wrap_CollidableProxy_GetSerializableName},
    { "CompoundCollisionShape_SerializableName", _wrap_CompoundCollisionShape_SerializableName},
    { "ConeCollisionShape_SerializableName", _wrap_ConeCollisionShape_SerializableName},
    { "Transform_SerializableName", _wrap_Transform_SerializableName},
    { "ConstraintParamAsString", _wrap_ConstraintParamAsString},
    { "StringAsConstraintParam", _wrap_StringAsConstraintParam},
    { "char4ToAxis", _wrap_char4ToAxis},
    { "Constraint_SerializableName", _wrap_Constraint_SerializableName},
    { "ConvexHullCollisionShape_SerializableName", _wrap_ConvexHullCollisionShape_SerializableName},
    { "CylinderCollisionShape_CreateHalfExtents", _wrap_CylinderCollisionShape_CreateHalfExtents},
    { "CylinderCollisionShape_SerializableName", _wrap_CylinderCollisionShape_SerializableName},
    { "DualTransformConstraint_SerializableName", _wrap_DualTransformConstraint_SerializableName},
    { "MeshCollisionShape_SerializableName", _wrap_MeshCollisionShape_SerializableName},
    { "FieldCollisionShape_SerializableName", _wrap_FieldCollisionShape_SerializableName},
    { "GearConstraint_SerializableName", _wrap_GearConstraint_SerializableName},
    { "Generic6DofConstraint_SerializableName", _wrap_Generic6DofConstraint_SerializableName},
    { "Generic6DofSpringConstraint_SerializableName", _wrap_Generic6DofSpringConstraint_SerializableName},
    { "GhostProxy_GetSerializableName", _wrap_GhostProxy_GetSerializableName},
    { "HingeConstraint_SerializableName", _wrap_HingeConstraint_SerializableName},
    { "MultiSphereCollisionShape_SerializableName", _wrap_MultiSphereCollisionShape_SerializableName},
    { "Plane_GetSerializableName", _wrap_Plane_GetSerializableName},
    { "PlaneCollisionShape_SerializableName", _wrap_PlaneCollisionShape_SerializableName},
    { "Point2PointConstraint_SerializableName", _wrap_Point2PointConstraint_SerializableName},
    { "RigidProxy_GetSerializableName", _wrap_RigidProxy_GetSerializableName},
    { "SoftProxy_GetSerializableName", _wrap_SoftProxy_GetSerializableName},
    { "SphereCollisionShape_SerializableName", _wrap_SphereCollisionShape_SerializableName},
    {0,0}
};

static swig_lua_var_info swig_variables[] = {
    { "ConstraintParamCount", _wrap_ConstraintParamCount_get, SWIG_Lua_set_immutable },
    {0,0,0}
};

static swig_lua_const_info swig_constants[] = {
    {SWIG_LUA_CONSTTAB_INT("AS_Active", Mezzanine::Physics::AS_Active)},
    {SWIG_LUA_CONSTTAB_INT("AS_Island_Sleeping", Mezzanine::Physics::AS_Island_Sleeping)},
    {SWIG_LUA_CONSTTAB_INT("AS_Wants_Deactivation", Mezzanine::Physics::AS_Wants_Deactivation)},
    {SWIG_LUA_CONSTTAB_INT("AS_DisableDeactivation", Mezzanine::Physics::AS_DisableDeactivation)},
    {SWIG_LUA_CONSTTAB_INT("AS_DisableSimulation", Mezzanine::Physics::AS_DisableSimulation)},
    {SWIG_LUA_CONSTTAB_INT("AFF_AnisotropicFrictionDisabled", Mezzanine::Physics::AFF_AnisotropicFrictionDisabled)},
    {SWIG_LUA_CONSTTAB_INT("AFF_AnisotropicFriction", Mezzanine::Physics::AFF_AnisotropicFriction)},
    {SWIG_LUA_CONSTTAB_INT("AFF_AnisotropicRollingFriction", Mezzanine::Physics::AFF_AnisotropicRollingFriction)},
    {SWIG_LUA_CONSTTAB_INT("CF_GenericFilter", Mezzanine::Physics::CF_GenericFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_StaticFilter", Mezzanine::Physics::CF_StaticFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_KinematicFilter", Mezzanine::Physics::CF_KinematicFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_DebrisFilter", Mezzanine::Physics::CF_DebrisFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_SensorFilter", Mezzanine::Physics::CF_SensorFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_CharacterFilter", Mezzanine::Physics::CF_CharacterFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_AllFilter", Mezzanine::Physics::CF_AllFilter)},
    {SWIG_LUA_CONSTTAB_INT("CF_UserFilter1", Mezzanine::Physics::CF_UserFilter1)},
    {SWIG_LUA_CONSTTAB_INT("CF_UserFilter2", Mezzanine::Physics::CF_UserFilter2)},
    {SWIG_LUA_CONSTTAB_INT("CF_UserFilter3", Mezzanine::Physics::CF_UserFilter3)},
    {SWIG_LUA_CONSTTAB_INT("CF_UserFilter4", Mezzanine::Physics::CF_UserFilter4)},
    {SWIG_LUA_CONSTTAB_INT("CF_StaticObject", Mezzanine::Physics::CF_StaticObject)},
    {SWIG_LUA_CONSTTAB_INT("CF_KinematicObject", Mezzanine::Physics::CF_KinematicObject)},
    {SWIG_LUA_CONSTTAB_INT("CF_NoContactResponse", Mezzanine::Physics::CF_NoContactResponse)},
    {SWIG_LUA_CONSTTAB_INT("CF_CustomMaterialCallback", Mezzanine::Physics::CF_CustomMaterialCallback)},
    {SWIG_LUA_CONSTTAB_INT("CF_CharacterObject", Mezzanine::Physics::CF_CharacterObject)},
    {SWIG_LUA_CONSTTAB_INT("CF_DisableVisualizeObject", Mezzanine::Physics::CF_DisableVisualizeObject)},
    {SWIG_LUA_CONSTTAB_INT("CF_DisableSPUCollisionProcessing", Mezzanine::Physics::CF_DisableSPUCollisionProcessing)},
    {SWIG_LUA_CONSTTAB_INT("Col_Begin", Mezzanine::Physics::Col_Begin)},
    {SWIG_LUA_CONSTTAB_INT("Col_Contacts_Updated", Mezzanine::Physics::Col_Contacts_Updated)},
    {SWIG_LUA_CONSTTAB_INT("Col_End", Mezzanine::Physics::Col_End)},
    {SWIG_LUA_CONSTTAB_INT("Col_Actor_Actor", Mezzanine::Physics::Col_Actor_Actor)},
    {SWIG_LUA_CONSTTAB_INT("Col_Actor_AreaEffect", Mezzanine::Physics::Col_Actor_AreaEffect)},
    {SWIG_LUA_CONSTTAB_INT("Col_Actor_Debris", Mezzanine::Physics::Col_Actor_Debris)},
    {SWIG_LUA_CONSTTAB_INT("Col_Actor_Terrain", Mezzanine::Physics::Col_Actor_Terrain)},
    {SWIG_LUA_CONSTTAB_INT("Col_AreaEffect_AreaEffect", Mezzanine::Physics::Col_AreaEffect_AreaEffect)},
    {SWIG_LUA_CONSTTAB_INT("Col_AreaEffect_Debris", Mezzanine::Physics::Col_AreaEffect_Debris)},
    {SWIG_LUA_CONSTTAB_INT("Col_AreaEffect_Terrain", Mezzanine::Physics::Col_AreaEffect_Terrain)},
    {SWIG_LUA_CONSTTAB_INT("Col_Debris_Debris", Mezzanine::Physics::Col_Debris_Debris)},
    {SWIG_LUA_CONSTTAB_INT("Col_Debris_Terrain", Mezzanine::Physics::Col_Debris_Terrain)},
    {SWIG_LUA_CONSTTAB_INT("DDM_NoDebug", Mezzanine::Physics::DDM_NoDebug)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawWireframe", Mezzanine::Physics::DDM_DrawWireframe)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawAABB", Mezzanine::Physics::DDM_DrawAABB)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawFeaturesText", Mezzanine::Physics::DDM_DrawFeaturesText)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawContactPoints", Mezzanine::Physics::DDM_DrawContactPoints)},
    {SWIG_LUA_CONSTTAB_INT("DDM_NoDeactivation", Mezzanine::Physics::DDM_NoDeactivation)},
    {SWIG_LUA_CONSTTAB_INT("DDM_NoHelpText", Mezzanine::Physics::DDM_NoHelpText)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawText", Mezzanine::Physics::DDM_DrawText)},
    {SWIG_LUA_CONSTTAB_INT("DDM_ProfileTimings", Mezzanine::Physics::DDM_ProfileTimings)},
    {SWIG_LUA_CONSTTAB_INT("DDM_EnableSatComparison", Mezzanine::Physics::DDM_EnableSatComparison)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DisableBulletLCP", Mezzanine::Physics::DDM_DisableBulletLCP)},
    {SWIG_LUA_CONSTTAB_INT("DDM_EnableCCD", Mezzanine::Physics::DDM_EnableCCD)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawConstraints", Mezzanine::Physics::DDM_DrawConstraints)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawConstraintLimits", Mezzanine::Physics::DDM_DrawConstraintLimits)},
    {SWIG_LUA_CONSTTAB_INT("DDM_FastWireframe", Mezzanine::Physics::DDM_FastWireframe)},
    {SWIG_LUA_CONSTTAB_INT("DDM_DrawNormals", Mezzanine::Physics::DDM_DrawNormals)},
    {SWIG_LUA_CONSTTAB_INT("DDM_All", Mezzanine::Physics::DDM_All)},
    {SWIG_LUA_CONSTTAB_INT("PT_Rigid", Mezzanine::Physics::PT_Rigid)},
    {SWIG_LUA_CONSTTAB_INT("PT_Soft", Mezzanine::Physics::PT_Soft)},
    {SWIG_LUA_CONSTTAB_INT("PT_Ghost", Mezzanine::Physics::PT_Ghost)},
    {SWIG_LUA_CONSTTAB_INT("MEZZANINE_CORE", 1)},
    {SWIG_LUA_CONSTTAB_INT("MEZZ_FRAMESTOTRACK", 10)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Box", Mezzanine::Physics::CollisionShape::ST_Box)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Capsule", Mezzanine::Physics::CollisionShape::ST_Capsule)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Compound", Mezzanine::Physics::CollisionShape::ST_Compound)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Cone", Mezzanine::Physics::CollisionShape::ST_Cone)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_ConvexHull", Mezzanine::Physics::CollisionShape::ST_ConvexHull)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Cylinder", Mezzanine::Physics::CollisionShape::ST_Cylinder)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_MultiSphere", Mezzanine::Physics::CollisionShape::ST_MultiSphere)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Sphere", Mezzanine::Physics::CollisionShape::ST_Sphere)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_DynamicTriMesh", Mezzanine::Physics::CollisionShape::ST_DynamicTriMesh)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Heightfield", Mezzanine::Physics::CollisionShape::ST_Heightfield)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Plane", Mezzanine::Physics::CollisionShape::ST_Plane)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_Soft", Mezzanine::Physics::CollisionShape::ST_Soft)},
    {SWIG_LUA_CONSTTAB_INT("CollisionShape_ST_StaticTriMesh", Mezzanine::Physics::CollisionShape::ST_StaticTriMesh)},
    {SWIG_LUA_CONSTTAB_INT("AT_FileSystem", Mezzanine::AT_FileSystem)},
    {SWIG_LUA_CONSTTAB_INT("AT_Zip", Mezzanine::AT_Zip)},
    {SWIG_LUA_CONSTTAB_INT("AT_Invalid", Mezzanine::AT_Invalid)},
    {SWIG_LUA_CONSTTAB_INT("Att_None", Mezzanine::Att_None)},
    {SWIG_LUA_CONSTTAB_INT("Att_Linear", Mezzanine::Att_Linear)},
    {SWIG_LUA_CONSTTAB_INT("Att_Quadratic", Mezzanine::Att_Quadratic)},
    {SWIG_LUA_CONSTTAB_INT("OM_Degree_0", Mezzanine::OM_Degree_0)},
    {SWIG_LUA_CONSTTAB_INT("OM_Degree_90", Mezzanine::OM_Degree_90)},
    {SWIG_LUA_CONSTTAB_INT("OM_Degree_180", Mezzanine::OM_Degree_180)},
    {SWIG_LUA_CONSTTAB_INT("OM_Degree_270", Mezzanine::OM_Degree_270)},
    {SWIG_LUA_CONSTTAB_INT("OM_Portrait", Mezzanine::OM_Portrait)},
    {SWIG_LUA_CONSTTAB_INT("OM_LandscapeRight", Mezzanine::OM_LandscapeRight)},
    {SWIG_LUA_CONSTTAB_INT("OM_LandscapeLeft", Mezzanine::OM_LandscapeLeft)},
    {SWIG_LUA_CONSTTAB_INT("PL_Unpaused", Mezzanine::PL_Unpaused)},
    {SWIG_LUA_CONSTTAB_INT("PL_PausePhysics", Mezzanine::PL_PausePhysics)},
    {SWIG_LUA_CONSTTAB_INT("PL_PauseParticles", Mezzanine::PL_PauseParticles)},
    {SWIG_LUA_CONSTTAB_INT("PL_PauseAnimations", Mezzanine::PL_PauseAnimations)},
    {SWIG_LUA_CONSTTAB_INT("PL_PauseAll", Mezzanine::PL_PauseAll)},
    {SWIG_LUA_CONSTTAB_INT("PT_Audio_First", Mezzanine::PT_Audio_First)},
    {SWIG_LUA_CONSTTAB_INT("PT_Audio_Listener", Mezzanine::PT_Audio_Listener)},
    {SWIG_LUA_CONSTTAB_INT("PT_Audio_SoundProxy", Mezzanine::PT_Audio_SoundProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Audio_Last", Mezzanine::PT_Audio_Last)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_First", Mezzanine::PT_Graphics_First)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_BillboardSetProxy", Mezzanine::PT_Graphics_BillboardSetProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_CameraProxy", Mezzanine::PT_Graphics_CameraProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_EntityProxy", Mezzanine::PT_Graphics_EntityProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_LightProxy", Mezzanine::PT_Graphics_LightProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_ParticleSystemProxy", Mezzanine::PT_Graphics_ParticleSystemProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_Last", Mezzanine::PT_Graphics_Last)},
    {SWIG_LUA_CONSTTAB_INT("PT_Physics_First", Mezzanine::PT_Physics_First)},
    {SWIG_LUA_CONSTTAB_INT("PT_Physics_GhostProxy", Mezzanine::PT_Physics_GhostProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Physics_RigidProxy", Mezzanine::PT_Physics_RigidProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Physics_SoftProxy", Mezzanine::PT_Physics_SoftProxy)},
    {SWIG_LUA_CONSTTAB_INT("PT_Physics_Last", Mezzanine::PT_Physics_Last)},
    {SWIG_LUA_CONSTTAB_INT("PT_Audio_All_Proxies", Mezzanine::PT_Audio_All_Proxies)},
    {SWIG_LUA_CONSTTAB_INT("PT_Graphics_All_Proxies", Mezzanine::PT_Graphics_All_Proxies)},
    {SWIG_LUA_CONSTTAB_INT("PT_Physics_All_Proxies", Mezzanine::PT_Physics_All_Proxies)},
    {SWIG_LUA_CONSTTAB_INT("Axis_Invalid", Mezzanine::Axis_Invalid)},
    {SWIG_LUA_CONSTTAB_INT("Axis_X", Mezzanine::Axis_X)},
    {SWIG_LUA_CONSTTAB_INT("Axis_Y", Mezzanine::Axis_Y)},
    {SWIG_LUA_CONSTTAB_INT("Axis_Z", Mezzanine::Axis_Z)},
    {SWIG_LUA_CONSTTAB_INT("TT_Simple", Mezzanine::TT_Simple)},
    {SWIG_LUA_CONSTTAB_INT("TT_Spline", Mezzanine::TT_Spline)},
    {SWIG_LUA_CONSTTAB_INT("TT_Bezier", Mezzanine::TT_Bezier)},
    {SWIG_LUA_CONSTTAB_INT("TS_Local", Mezzanine::TS_Local)},
    {SWIG_LUA_CONSTTAB_INT("TS_Parent", Mezzanine::TS_Parent)},
    {SWIG_LUA_CONSTTAB_INT("TS_World", Mezzanine::TS_World)},
    {SWIG_LUA_CONSTTAB_INT("WO_TerrainFirst", Mezzanine::WO_TerrainFirst)},
    {SWIG_LUA_CONSTTAB_INT("WO_MeshTerrain", Mezzanine::WO_MeshTerrain)},
    {SWIG_LUA_CONSTTAB_INT("WO_HeightfieldTerrain", Mezzanine::WO_HeightfieldTerrain)},
    {SWIG_LUA_CONSTTAB_INT("WO_VectorFieldTerrain", Mezzanine::WO_VectorFieldTerrain)},
    {SWIG_LUA_CONSTTAB_INT("WO_VoxelTerrain", Mezzanine::WO_VoxelTerrain)},
    {SWIG_LUA_CONSTTAB_INT("WO_MarchingCubeTerrain", Mezzanine::WO_MarchingCubeTerrain)},
    {SWIG_LUA_CONSTTAB_INT("WO_UnknownTerrain", Mezzanine::WO_UnknownTerrain)},
    {SWIG_LUA_CONSTTAB_INT("WO_TerrainLast", Mezzanine::WO_TerrainLast)},
    {SWIG_LUA_CONSTTAB_INT("WO_DebrisFirst", Mezzanine::WO_DebrisFirst)},
    {SWIG_LUA_CONSTTAB_INT("WO_DebrisRigid", Mezzanine::WO_DebrisRigid)},
    {SWIG_LUA_CONSTTAB_INT("WO_DebrisSoft", Mezzanine::WO_DebrisSoft)},
    {SWIG_LUA_CONSTTAB_INT("WO_DebrisUnknown", Mezzanine::WO_DebrisUnknown)},
    {SWIG_LUA_CONSTTAB_INT("WO_DebrisLast", Mezzanine::WO_DebrisLast)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectFirst", Mezzanine::WO_AreaEffectFirst)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectGravityField", Mezzanine::WO_AreaEffectGravityField)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectGravityWell", Mezzanine::WO_AreaEffectGravityWell)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectFieldOfForce", Mezzanine::WO_AreaEffectFieldOfForce)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectPlaceHolder1", Mezzanine::WO_AreaEffectPlaceHolder1)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectPlaceHolder2", Mezzanine::WO_AreaEffectPlaceHolder2)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectUnknown", Mezzanine::WO_AreaEffectUnknown)},
    {SWIG_LUA_CONSTTAB_INT("WO_AreaEffectLast", Mezzanine::WO_AreaEffectLast)},
    {SWIG_LUA_CONSTTAB_INT("WO_ActorFirst", Mezzanine::WO_ActorFirst)},
    {SWIG_LUA_CONSTTAB_INT("WO_ActorPlaceHolder1", Mezzanine::WO_ActorPlaceHolder1)},
    {SWIG_LUA_CONSTTAB_INT("WO_ActorPlaceHolder2", Mezzanine::WO_ActorPlaceHolder2)},
    {SWIG_LUA_CONSTTAB_INT("WO_ActorPlaceHolder3", Mezzanine::WO_ActorPlaceHolder3)},
    {SWIG_LUA_CONSTTAB_INT("WO_ActorLast", Mezzanine::WO_ActorLast)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehicleFirst", Mezzanine::WO_VehicleFirst)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehiclePlaceHolder1", Mezzanine::WO_VehiclePlaceHolder1)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehiclePlaceHolder2", Mezzanine::WO_VehiclePlaceHolder2)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehiclePlaceHolder3", Mezzanine::WO_VehiclePlaceHolder3)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehiclePlaceHolder4", Mezzanine::WO_VehiclePlaceHolder4)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehiclePlaceHolder5", Mezzanine::WO_VehiclePlaceHolder5)},
    {SWIG_LUA_CONSTTAB_INT("WO_VehicleLast", Mezzanine::WO_VehicleLast)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_EXCEPTION", Mezzanine::Exception::IO_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_FILE_EXCEPTION", Mezzanine::Exception::IO_FILE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_FILE_READ_EXCEPTION", Mezzanine::Exception::IO_FILE_READ_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_FILE_WRITE_EXCEPTION", Mezzanine::Exception::IO_FILE_WRITE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_FILE_NOT_FOUND_EXCEPTION", Mezzanine::Exception::IO_FILE_NOT_FOUND_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_FILE_PERMISSION_EXCEPTION", Mezzanine::Exception::IO_FILE_PERMISSION_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_DIRECTORY_EXCEPTION", Mezzanine::Exception::IO_DIRECTORY_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_DIRECTORY_READ_EXCEPTION", Mezzanine::Exception::IO_DIRECTORY_READ_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_DIRECTORY_WRITE_EXCEPTION", Mezzanine::Exception::IO_DIRECTORY_WRITE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_DIRECTORY_NOT_FOUND_EXCEPTION", Mezzanine::Exception::IO_DIRECTORY_NOT_FOUND_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_DIRECTORY_PERMISSION_EXCEPTION", Mezzanine::Exception::IO_DIRECTORY_PERMISSION_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_NETWORK_EXCEPTION", Mezzanine::Exception::IO_NETWORK_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_NETWORK_READ_EXCEPTION", Mezzanine::Exception::IO_NETWORK_READ_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_NETWORK_WRITE_EXCEPTION", Mezzanine::Exception::IO_NETWORK_WRITE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_NETWORK_NOT_FOUND_EXCEPTION", Mezzanine::Exception::IO_NETWORK_NOT_FOUND_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_NETWORK_URL_EXCEPTION", Mezzanine::Exception::IO_NETWORK_URL_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_NETWORK_PERMISSION_EXCEPTION", Mezzanine::Exception::IO_NETWORK_PERMISSION_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_WRITE_EXCEPTION", Mezzanine::Exception::IO_WRITE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_IO_READ_EXCEPTION", Mezzanine::Exception::IO_READ_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_II_EXCEPTION", Mezzanine::Exception::II_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_II_IDENTITY_INVALID_EXCEPTION", Mezzanine::Exception::II_IDENTITY_INVALID_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_II_IDENTITY_NOT_FOUND_EXCEPTION", Mezzanine::Exception::II_IDENTITY_NOT_FOUND_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_II_DUPLICATE_IDENTITY_EXCEPTION", Mezzanine::Exception::II_DUPLICATE_IDENTITY_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_MM_EXCEPTION", Mezzanine::Exception::MM_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_MM_OUT_OF_MEMORY_EXCEPTION", Mezzanine::Exception::MM_OUT_OF_MEMORY_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_MM_OUT_OF_BOUNDS_EXCEPTION", Mezzanine::Exception::MM_OUT_OF_BOUNDS_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SYNTAX_ERROR_EXCEPTION", Mezzanine::Exception::SYNTAX_ERROR_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SYNTAX_ERROR_EXCEPTION_XML", Mezzanine::Exception::SYNTAX_ERROR_EXCEPTION_XML)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SYNTAX_ERROR_EXCEPTION_XPATH", Mezzanine::Exception::SYNTAX_ERROR_EXCEPTION_XPATH)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SYNTAX_ERROR_EXCEPTION_LUA", Mezzanine::Exception::SYNTAX_ERROR_EXCEPTION_LUA)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SCRIPT_EXCEPTION", Mezzanine::Exception::SCRIPT_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SCRIPT_EXCEPTION_LUA", Mezzanine::Exception::SCRIPT_EXCEPTION_LUA)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SCRIPT_EXCEPTION_LUA_YIELD", Mezzanine::Exception::SCRIPT_EXCEPTION_LUA_YIELD)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SCRIPT_EXCEPTION_LUA_RUNTIME", Mezzanine::Exception::SCRIPT_EXCEPTION_LUA_RUNTIME)},
    {SWIG_LUA_CONSTTAB_INT("Exception_SCRIPT_EXCEPTION_LUA_ERRERR", Mezzanine::Exception::SCRIPT_EXCEPTION_LUA_ERRERR)},
    {SWIG_LUA_CONSTTAB_INT("Exception_PARAMETERS_EXCEPTION", Mezzanine::Exception::PARAMETERS_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_PARAMETERS_CAST_EXCEPTION", Mezzanine::Exception::PARAMETERS_CAST_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_PARAMETERS_RANGE_EXCEPTION", Mezzanine::Exception::PARAMETERS_RANGE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_ARITHMETIC_EXCEPTION", Mezzanine::Exception::ARITHMETIC_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_INVALID_VERSION_EXCEPTION", Mezzanine::Exception::INVALID_VERSION_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_INVALID_STATE_EXCEPTION", Mezzanine::Exception::INVALID_STATE_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_RENDERINGAPI_EXCEPTION", Mezzanine::Exception::RENDERINGAPI_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_RT_ASSERTION_EXCEPTION", Mezzanine::Exception::RT_ASSERTION_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_INTERNAL_EXCEPTION", Mezzanine::Exception::INTERNAL_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_NOT_IMPLEMENTED_EXCEPTION", Mezzanine::Exception::NOT_IMPLEMENTED_EXCEPTION)},
    {SWIG_LUA_CONSTTAB_INT("Exception_INVALID_ASSIGNMENT", Mezzanine::Exception::INVALID_ASSIGNMENT)},
    {SWIG_LUA_CONSTTAB_INT("IOException_ExceptionCode", Mezzanine::IOException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("FileException_ExceptionCode", Mezzanine::FileException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("FileReadException_ExceptionCode", Mezzanine::FileReadException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("FileWriteException_ExceptionCode", Mezzanine::FileWriteException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("FileNotFoundException_ExceptionCode", Mezzanine::FileNotFoundException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("FilePermissionException_ExceptionCode", Mezzanine::FilePermissionException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("DirectoryException_ExceptionCode", Mezzanine::DirectoryException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("DirectoryReadException_ExceptionCode", Mezzanine::DirectoryReadException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("DirectoryWriteException_ExceptionCode", Mezzanine::DirectoryWriteException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("DirectoryNotFoundException_ExceptionCode", Mezzanine::DirectoryNotFoundException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("DirectoryPermissionException_ExceptionCode", Mezzanine::DirectoryPermissionException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NetworkException_ExceptionCode", Mezzanine::NetworkException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NetworkReadException_ExceptionCode", Mezzanine::NetworkReadException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NetworkWriteException_ExceptionCode", Mezzanine::NetworkWriteException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NetworkNotFoundException_ExceptionCode", Mezzanine::NetworkNotFoundException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NetworkURLException_ExceptionCode", Mezzanine::NetworkURLException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NetworkPermissionException_ExceptionCode", Mezzanine::NetworkPermissionException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("IOWriteException_ExceptionCode", Mezzanine::IOWriteException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("IOReadException_ExceptionCode", Mezzanine::IOReadException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InstanceIdentityException_ExceptionCode", Mezzanine::InstanceIdentityException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InstanceIdentityInvalidException_ExceptionCode", Mezzanine::InstanceIdentityInvalidException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InstanceIdentityNotFoundException_ExceptionCode", Mezzanine::InstanceIdentityNotFoundException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InstanceIdentityDuplicateException_ExceptionCode", Mezzanine::InstanceIdentityDuplicateException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("MemoryManagementException_ExceptionCode", Mezzanine::MemoryManagementException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("OutOfMemoryException_ExceptionCode", Mezzanine::OutOfMemoryException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("MemoryOutOfBoundsException_ExceptionCode", Mezzanine::MemoryOutOfBoundsException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("SyntaxErrorException_ExceptionCode", Mezzanine::SyntaxErrorException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("SyntaxErrorXMLException_ExceptionCode", Mezzanine::SyntaxErrorXMLException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("SyntaxErrorXPathException_ExceptionCode", Mezzanine::SyntaxErrorXPathException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("SyntaxErrorLuaException_ExceptionCode", Mezzanine::SyntaxErrorLuaException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ScriptException_ExceptionCode", Mezzanine::ScriptException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ScriptLuaException_ExceptionCode", Mezzanine::ScriptLuaException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ScriptLuaYieldException_ExceptionCode", Mezzanine::ScriptLuaYieldException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ScriptLuaRuntimeException_ExceptionCode", Mezzanine::ScriptLuaRuntimeException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ScriptLuaErrErrException_ExceptionCode", Mezzanine::ScriptLuaErrErrException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ParametersException_ExceptionCode", Mezzanine::ParametersException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ParametersCastException_ExceptionCode", Mezzanine::ParametersCastException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ParametersRangeException_ExceptionCode", Mezzanine::ParametersRangeException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("ArithmeticException_ExceptionCode", Mezzanine::ArithmeticException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InvalidVersionException_ExceptionCode", Mezzanine::InvalidVersionException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InvalidStateException_ExceptionCode", Mezzanine::InvalidStateException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("RenderingAPIException_ExceptionCode", Mezzanine::RenderingAPIException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("RuntimeAssertionException_ExceptionCode", Mezzanine::RuntimeAssertionException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InternalException_ExceptionCode", Mezzanine::InternalException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("NotImplementedException_ExceptionCode", Mezzanine::NotImplementedException::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("InvalidAssignment_ExceptionCode", Mezzanine::InvalidAssignment::ExceptionCode)},
    {SWIG_LUA_CONSTTAB_INT("CastNoneError", Mezzanine::CastNoneError)},
    {SWIG_LUA_CONSTTAB_INT("CastNoneReturnZero", Mezzanine::CastNoneReturnZero)},
    {SWIG_LUA_CONSTTAB_INT("CastImplicit", Mezzanine::CastImplicit)},
    {SWIG_LUA_CONSTTAB_INT("CastStatic", Mezzanine::CastStatic)},
    {SWIG_LUA_CONSTTAB_INT("CastDynamic", Mezzanine::CastDynamic)},
    {SWIG_LUA_CONSTTAB_INT("Con_ERP", Mezzanine::Physics::Con_ERP)},
    {SWIG_LUA_CONSTTAB_INT("Con_Stop_ERP", Mezzanine::Physics::Con_Stop_ERP)},
    {SWIG_LUA_CONSTTAB_INT("Con_CFM", Mezzanine::Physics::Con_CFM)},
    {SWIG_LUA_CONSTTAB_INT("Con_Stop_CFM", Mezzanine::Physics::Con_Stop_CFM)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_LinearX", Mezzanine::Physics::Generic6DofConstraint::LinearX)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_LinearY", Mezzanine::Physics::Generic6DofConstraint::LinearY)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_LinearZ", Mezzanine::Physics::Generic6DofConstraint::LinearZ)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_AngularX", Mezzanine::Physics::Generic6DofConstraint::AngularX)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_AngularY", Mezzanine::Physics::Generic6DofConstraint::AngularY)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_AngularZ", Mezzanine::Physics::Generic6DofConstraint::AngularZ)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_AngularXAsRotationalAxis", Mezzanine::Physics::Generic6DofConstraint::AngularXAsRotationalAxis)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_AngularYAsRotationalAxis", Mezzanine::Physics::Generic6DofConstraint::AngularYAsRotationalAxis)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofConstraint_AngularZAsRotationalAxis", Mezzanine::Physics::Generic6DofConstraint::AngularZAsRotationalAxis)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofSpringConstraint_LinearX", Mezzanine::Physics::Generic6DofSpringConstraint::LinearX)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofSpringConstraint_LinearY", Mezzanine::Physics::Generic6DofSpringConstraint::LinearY)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofSpringConstraint_LinearZ", Mezzanine::Physics::Generic6DofSpringConstraint::LinearZ)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofSpringConstraint_AngularX", Mezzanine::Physics::Generic6DofSpringConstraint::AngularX)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofSpringConstraint_AngularY", Mezzanine::Physics::Generic6DofSpringConstraint::AngularY)},
    {SWIG_LUA_CONSTTAB_INT("Generic6DofSpringConstraint_AngularZ", Mezzanine::Physics::Generic6DofSpringConstraint::AngularZ)},
    {SWIG_LUA_CONSTTAB_INT("ManagerConstructionInfo_PCF_SoftRigidWorld", Mezzanine::Physics::ManagerConstructionInfo::PCF_SoftRigidWorld)},
    {SWIG_LUA_CONSTTAB_INT("ManagerConstructionInfo_PCF_LimitlessWorld", Mezzanine::Physics::ManagerConstructionInfo::PCF_LimitlessWorld)},
    {SWIG_LUA_CONSTTAB_INT("ManagerConstructionInfo_PCF_Multithreaded", Mezzanine::Physics::ManagerConstructionInfo::PCF_Multithreaded)},
    {SWIG_LUA_CONSTTAB_INT("Plane_S_None", Mezzanine::Plane::S_None)},
    {SWIG_LUA_CONSTTAB_INT("Plane_S_Positive", Mezzanine::Plane::S_Positive)},
    {SWIG_LUA_CONSTTAB_INT("Plane_S_Negative", Mezzanine::Plane::S_Negative)},
    {SWIG_LUA_CONSTTAB_INT("Plane_S_Both", Mezzanine::Plane::S_Both)},
    {0,0,0,0,0,0}
};

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_Mezzanine__Physics__Generic6DofSpringConstraintTo_p_Mezzanine__Physics__Generic6DofConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Generic6DofConstraint *)  ((Mezzanine::Physics::Generic6DofSpringConstraint *) x));
}
static void *_p_Mezzanine__Physics__UniversalConstraintTo_p_Mezzanine__Physics__Generic6DofConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Generic6DofConstraint *)  ((Mezzanine::Physics::UniversalConstraint *) x));
}
static void *_p_Mezzanine__Physics__Generic6DofConstraintTo_p_Mezzanine__Physics__DualTransformConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::DualTransformConstraint *)  ((Mezzanine::Physics::Generic6DofConstraint *) x));
}
static void *_p_Mezzanine__Physics__Generic6DofSpringConstraintTo_p_Mezzanine__Physics__DualTransformConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::DualTransformConstraint *) (Mezzanine::Physics::Generic6DofConstraint *) ((Mezzanine::Physics::Generic6DofSpringConstraint *) x));
}
static void *_p_Mezzanine__Physics__HingeConstraintTo_p_Mezzanine__Physics__DualTransformConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::DualTransformConstraint *)  ((Mezzanine::Physics::HingeConstraint *) x));
}
static void *_p_Mezzanine__Physics__SliderConstraintTo_p_Mezzanine__Physics__DualTransformConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::DualTransformConstraint *)  ((Mezzanine::Physics::SliderConstraint *) x));
}
static void *_p_Mezzanine__Physics__UniversalConstraintTo_p_Mezzanine__Physics__DualTransformConstraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::DualTransformConstraint *) (Mezzanine::Physics::Generic6DofConstraint *) ((Mezzanine::Physics::UniversalConstraint *) x));
}
static void *_p_Mezzanine__Physics__DualTransformConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *)  ((Mezzanine::Physics::DualTransformConstraint *) x));
}
static void *_p_Mezzanine__Physics__GearConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *)  ((Mezzanine::Physics::GearConstraint *) x));
}
static void *_p_Mezzanine__Physics__Generic6DofConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *) (Mezzanine::Physics::DualTransformConstraint *) ((Mezzanine::Physics::Generic6DofConstraint *) x));
}
static void *_p_Mezzanine__Physics__Generic6DofSpringConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *) (Mezzanine::Physics::DualTransformConstraint *)(Mezzanine::Physics::Generic6DofConstraint *) ((Mezzanine::Physics::Generic6DofSpringConstraint *) x));
}
static void *_p_Mezzanine__Physics__HingeConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *) (Mezzanine::Physics::DualTransformConstraint *) ((Mezzanine::Physics::HingeConstraint *) x));
}
static void *_p_Mezzanine__Physics__Point2PointConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *)  ((Mezzanine::Physics::Point2PointConstraint *) x));
}
static void *_p_Mezzanine__Physics__SliderConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *) (Mezzanine::Physics::DualTransformConstraint *) ((Mezzanine::Physics::SliderConstraint *) x));
}
static void *_p_Mezzanine__Physics__UniversalConstraintTo_p_Mezzanine__Physics__Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::Constraint *) (Mezzanine::Physics::DualTransformConstraint *)(Mezzanine::Physics::Generic6DofConstraint *) ((Mezzanine::Physics::UniversalConstraint *) x));
}
static void *_p_Mezzanine__Physics__HeightfieldCollisionShapeTo_p_Mezzanine__Physics__FieldCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::FieldCollisionShape *)  ((Mezzanine::Physics::HeightfieldCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__PlaneCollisionShapeTo_p_Mezzanine__Physics__FieldCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::FieldCollisionShape *)  ((Mezzanine::Physics::PlaneCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__DynamicMeshCollisionShapeTo_p_Mezzanine__Physics__MeshCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::MeshCollisionShape *)  ((Mezzanine::Physics::DynamicMeshCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__SoftCollisionShapeTo_p_Mezzanine__Physics__MeshCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::MeshCollisionShape *)  ((Mezzanine::Physics::SoftCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__StaticMeshCollisionShapeTo_p_Mezzanine__Physics__MeshCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::MeshCollisionShape *)  ((Mezzanine::Physics::StaticMeshCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__SoftCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::MeshCollisionShape *) ((Mezzanine::Physics::SoftCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__PlaneCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::FieldCollisionShape *) ((Mezzanine::Physics::PlaneCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__MultiSphereCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::MultiSphereCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__HeightfieldCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::FieldCollisionShape *) ((Mezzanine::Physics::HeightfieldCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__FieldCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *)  ((Mezzanine::Physics::FieldCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__DynamicMeshCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::MeshCollisionShape *) ((Mezzanine::Physics::DynamicMeshCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__MeshCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *)  ((Mezzanine::Physics::MeshCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__CylinderCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::CylinderCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__ConvexHullCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::ConvexHullCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__ConeCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::ConeCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__CompoundCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *)  ((Mezzanine::Physics::CompoundCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__CapsuleCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::CapsuleCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__BoxCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::BoxCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__PrimitiveCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *)  ((Mezzanine::Physics::PrimitiveCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__SphereCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::PrimitiveCollisionShape *) ((Mezzanine::Physics::SphereCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__StaticMeshCollisionShapeTo_p_Mezzanine__Physics__CollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollisionShape *) (Mezzanine::Physics::MeshCollisionShape *) ((Mezzanine::Physics::StaticMeshCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__BoxCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::BoxCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__CapsuleCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::CapsuleCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__ConeCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::ConeCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__ConvexHullCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::ConvexHullCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__CylinderCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::CylinderCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__MultiSphereCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::MultiSphereCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__SphereCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::PrimitiveCollisionShape *)  ((Mezzanine::Physics::SphereCollisionShape *) x));
}
static void *_p_Mezzanine__Physics__CollidableProxyTo_p_Mezzanine__TransformableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::TransformableObject *) (Mezzanine::WorldProxy *) ((Mezzanine::Physics::CollidableProxy *) x));
}
static void *_p_Mezzanine__Physics__GhostProxyTo_p_Mezzanine__TransformableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::TransformableObject *) (Mezzanine::WorldProxy *)(Mezzanine::Physics::CollidableProxy *) ((Mezzanine::Physics::GhostProxy *) x));
}
static void *_p_Mezzanine__Physics__SoftProxyTo_p_Mezzanine__TransformableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::TransformableObject *) (Mezzanine::WorldProxy *)(Mezzanine::Physics::CollidableProxy *) ((Mezzanine::Physics::SoftProxy *) x));
}
static void *_p_Mezzanine__Physics__RigidProxyTo_p_Mezzanine__TransformableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::TransformableObject *) (Mezzanine::WorldProxy *)(Mezzanine::Physics::CollidableProxy *) ((Mezzanine::Physics::RigidProxy *) x));
}
static void *_p_Mezzanine__WorldProxyTo_p_Mezzanine__TransformableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::TransformableObject *)  ((Mezzanine::WorldProxy *) x));
}
static void *_p_Mezzanine__Physics__CollidableProxyTo_p_Mezzanine__WorldProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::WorldProxy *)  ((Mezzanine::Physics::CollidableProxy *) x));
}
static void *_p_Mezzanine__Physics__GhostProxyTo_p_Mezzanine__WorldProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::WorldProxy *) (Mezzanine::Physics::CollidableProxy *) ((Mezzanine::Physics::GhostProxy *) x));
}
static void *_p_Mezzanine__Physics__SoftProxyTo_p_Mezzanine__WorldProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::WorldProxy *) (Mezzanine::Physics::CollidableProxy *) ((Mezzanine::Physics::SoftProxy *) x));
}
static void *_p_Mezzanine__Physics__RigidProxyTo_p_Mezzanine__WorldProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::WorldProxy *) (Mezzanine::Physics::CollidableProxy *) ((Mezzanine::Physics::RigidProxy *) x));
}
static void *_p_Mezzanine__Physics__CollisionShapeManagerTo_p_ManagerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ManagerBase *)  ((Mezzanine::Physics::CollisionShapeManager *) x));
}
static void *_p_Mezzanine__InvalidAssignmentTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::InvalidAssignment *) x));
}
static void *_p_Mezzanine__ScriptLuaYieldExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::ScriptException *)(Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaYieldException *) x));
}
static void *_p_Mezzanine__ScriptLuaExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::ScriptException *) ((Mezzanine::ScriptLuaException *) x));
}
static void *_p_Mezzanine__ScriptExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::ScriptException *) x));
}
static void *_p_Mezzanine__SyntaxErrorLuaExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::SyntaxErrorException *) ((Mezzanine::SyntaxErrorLuaException *) x));
}
static void *_p_Mezzanine__SyntaxErrorXPathExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::SyntaxErrorException *) ((Mezzanine::SyntaxErrorXPathException *) x));
}
static void *_p_Mezzanine__SyntaxErrorXMLExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::SyntaxErrorException *) ((Mezzanine::SyntaxErrorXMLException *) x));
}
static void *_p_Mezzanine__SyntaxErrorExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::SyntaxErrorException *) x));
}
static void *_p_Mezzanine__MemoryOutOfBoundsExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::MemoryManagementException *) ((Mezzanine::MemoryOutOfBoundsException *) x));
}
static void *_p_Mezzanine__OutOfMemoryExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::MemoryManagementException *) ((Mezzanine::OutOfMemoryException *) x));
}
static void *_p_Mezzanine__MemoryManagementExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::MemoryManagementException *) x));
}
static void *_p_Mezzanine__InstanceIdentityDuplicateExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::InstanceIdentityException *) ((Mezzanine::InstanceIdentityDuplicateException *) x));
}
static void *_p_Mezzanine__InstanceIdentityNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::InstanceIdentityException *) ((Mezzanine::InstanceIdentityNotFoundException *) x));
}
static void *_p_Mezzanine__InstanceIdentityInvalidExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::InstanceIdentityException *) ((Mezzanine::InstanceIdentityInvalidException *) x));
}
static void *_p_Mezzanine__InstanceIdentityExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::InstanceIdentityException *) x));
}
static void *_p_Mezzanine__IOReadExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *) ((Mezzanine::IOReadException *) x));
}
static void *_p_Mezzanine__IOWriteExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *) ((Mezzanine::IOWriteException *) x));
}
static void *_p_Mezzanine__NetworkPermissionExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkPermissionException *) x));
}
static void *_p_Mezzanine__NetworkURLExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkURLException *) x));
}
static void *_p_Mezzanine__NetworkNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkNotFoundException *) x));
}
static void *_p_Mezzanine__NetworkWriteExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkWriteException *) x));
}
static void *_p_Mezzanine__ExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *)  ((Mezzanine::Exception *) x));
}
static void *_p_Mezzanine__IOExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::IOException *) x));
}
static void *_p_Mezzanine__FileExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *) ((Mezzanine::FileException *) x));
}
static void *_p_Mezzanine__FileReadExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FileReadException *) x));
}
static void *_p_Mezzanine__FileWriteExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FileWriteException *) x));
}
static void *_p_Mezzanine__FileNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FileNotFoundException *) x));
}
static void *_p_Mezzanine__FilePermissionExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FilePermissionException *) x));
}
static void *_p_Mezzanine__DirectoryExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *) ((Mezzanine::DirectoryException *) x));
}
static void *_p_Mezzanine__DirectoryReadExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryReadException *) x));
}
static void *_p_Mezzanine__DirectoryWriteExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryWriteException *) x));
}
static void *_p_Mezzanine__DirectoryNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryNotFoundException *) x));
}
static void *_p_Mezzanine__DirectoryPermissionExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryPermissionException *) x));
}
static void *_p_Mezzanine__NetworkExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *) ((Mezzanine::NetworkException *) x));
}
static void *_p_Mezzanine__NetworkReadExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkReadException *) x));
}
static void *_p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::ScriptException *)(Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaRuntimeException *) x));
}
static void *_p_Mezzanine__ScriptLuaErrErrExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::ScriptException *)(Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaErrErrException *) x));
}
static void *_p_Mezzanine__ParametersExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::ParametersException *) x));
}
static void *_p_Mezzanine__ParametersCastExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::ParametersException *) ((Mezzanine::ParametersCastException *) x));
}
static void *_p_Mezzanine__ParametersRangeExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *)(Mezzanine::ParametersException *) ((Mezzanine::ParametersRangeException *) x));
}
static void *_p_Mezzanine__ArithmeticExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::ArithmeticException *) x));
}
static void *_p_Mezzanine__InvalidVersionExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::InvalidVersionException *) x));
}
static void *_p_Mezzanine__InvalidStateExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::InvalidStateException *) x));
}
static void *_p_Mezzanine__RenderingAPIExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::RenderingAPIException *) x));
}
static void *_p_Mezzanine__RuntimeAssertionExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::RuntimeAssertionException *) x));
}
static void *_p_Mezzanine__InternalExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::InternalException *) x));
}
static void *_p_Mezzanine__NotImplementedExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Mezzanine::Exception *) ((Mezzanine::NotImplementedException *) x));
}
static void *_p_Mezzanine__InvalidAssignmentTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::InvalidAssignment *) x));
}
static void *_p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::ScriptException *)(Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaRuntimeException *) x));
}
static void *_p_Mezzanine__ScriptLuaYieldExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::ScriptException *)(Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaYieldException *) x));
}
static void *_p_Mezzanine__ScriptLuaExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::ScriptException *) ((Mezzanine::ScriptLuaException *) x));
}
static void *_p_Mezzanine__ScriptExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::ScriptException *) x));
}
static void *_p_Mezzanine__SyntaxErrorLuaExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::SyntaxErrorException *) ((Mezzanine::SyntaxErrorLuaException *) x));
}
static void *_p_Mezzanine__SyntaxErrorXPathExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::SyntaxErrorException *) ((Mezzanine::SyntaxErrorXPathException *) x));
}
static void *_p_Mezzanine__SyntaxErrorXMLExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::SyntaxErrorException *) ((Mezzanine::SyntaxErrorXMLException *) x));
}
static void *_p_Mezzanine__SyntaxErrorExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::SyntaxErrorException *) x));
}
static void *_p_Mezzanine__MemoryOutOfBoundsExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::MemoryManagementException *) ((Mezzanine::MemoryOutOfBoundsException *) x));
}
static void *_p_Mezzanine__OutOfMemoryExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::MemoryManagementException *) ((Mezzanine::OutOfMemoryException *) x));
}
static void *_p_Mezzanine__MemoryManagementExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::MemoryManagementException *) x));
}
static void *_p_Mezzanine__InstanceIdentityDuplicateExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::InstanceIdentityException *) ((Mezzanine::InstanceIdentityDuplicateException *) x));
}
static void *_p_Mezzanine__InstanceIdentityNotFoundExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::InstanceIdentityException *) ((Mezzanine::InstanceIdentityNotFoundException *) x));
}
static void *_p_Mezzanine__InstanceIdentityInvalidExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::InstanceIdentityException *) ((Mezzanine::InstanceIdentityInvalidException *) x));
}
static void *_p_Mezzanine__InstanceIdentityExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::InstanceIdentityException *) x));
}
static void *_p_Mezzanine__IOReadExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *) ((Mezzanine::IOReadException *) x));
}
static void *_p_Mezzanine__IOWriteExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *) ((Mezzanine::IOWriteException *) x));
}
static void *_p_Mezzanine__NetworkPermissionExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkPermissionException *) x));
}
static void *_p_Mezzanine__NetworkURLExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkURLException *) x));
}
static void *_p_Mezzanine__NetworkNotFoundExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkNotFoundException *) x));
}
static void *_p_Mezzanine__IOExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::IOException *) x));
}
static void *_p_Mezzanine__FileExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *) ((Mezzanine::FileException *) x));
}
static void *_p_Mezzanine__FileReadExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FileReadException *) x));
}
static void *_p_Mezzanine__FileWriteExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FileWriteException *) x));
}
static void *_p_Mezzanine__FileNotFoundExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FileNotFoundException *) x));
}
static void *_p_Mezzanine__FilePermissionExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::FileException *) ((Mezzanine::FilePermissionException *) x));
}
static void *_p_Mezzanine__DirectoryExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *) ((Mezzanine::DirectoryException *) x));
}
static void *_p_Mezzanine__DirectoryReadExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryReadException *) x));
}
static void *_p_Mezzanine__DirectoryWriteExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryWriteException *) x));
}
static void *_p_Mezzanine__DirectoryNotFoundExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryNotFoundException *) x));
}
static void *_p_Mezzanine__DirectoryPermissionExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::DirectoryException *) ((Mezzanine::DirectoryPermissionException *) x));
}
static void *_p_Mezzanine__NetworkExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *) ((Mezzanine::NetworkException *) x));
}
static void *_p_Mezzanine__NetworkReadExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkReadException *) x));
}
static void *_p_Mezzanine__NetworkWriteExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::IOException *)(Mezzanine::NetworkException *) ((Mezzanine::NetworkWriteException *) x));
}
static void *_p_Mezzanine__ScriptLuaErrErrExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::ScriptException *)(Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaErrErrException *) x));
}
static void *_p_Mezzanine__ParametersExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::ParametersException *) x));
}
static void *_p_Mezzanine__ParametersCastExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::ParametersException *) ((Mezzanine::ParametersCastException *) x));
}
static void *_p_Mezzanine__ParametersRangeExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *) (Mezzanine::ParametersException *) ((Mezzanine::ParametersRangeException *) x));
}
static void *_p_Mezzanine__ArithmeticExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::ArithmeticException *) x));
}
static void *_p_Mezzanine__InvalidVersionExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::InvalidVersionException *) x));
}
static void *_p_Mezzanine__InvalidStateExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::InvalidStateException *) x));
}
static void *_p_Mezzanine__RenderingAPIExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::RenderingAPIException *) x));
}
static void *_p_Mezzanine__RuntimeAssertionExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::RuntimeAssertionException *) x));
}
static void *_p_Mezzanine__InternalExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::InternalException *) x));
}
static void *_p_Mezzanine__NotImplementedExceptionTo_p_Mezzanine__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Exception *)  ((Mezzanine::NotImplementedException *) x));
}
static void *_p_Mezzanine__NetworkNotFoundExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::NetworkException *) ((Mezzanine::NetworkNotFoundException *) x));
}
static void *_p_Mezzanine__NetworkWriteExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::NetworkException *) ((Mezzanine::NetworkWriteException *) x));
}
static void *_p_Mezzanine__NetworkReadExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::NetworkException *) ((Mezzanine::NetworkReadException *) x));
}
static void *_p_Mezzanine__NetworkExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *)  ((Mezzanine::NetworkException *) x));
}
static void *_p_Mezzanine__DirectoryPermissionExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::DirectoryException *) ((Mezzanine::DirectoryPermissionException *) x));
}
static void *_p_Mezzanine__DirectoryNotFoundExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::DirectoryException *) ((Mezzanine::DirectoryNotFoundException *) x));
}
static void *_p_Mezzanine__DirectoryWriteExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::DirectoryException *) ((Mezzanine::DirectoryWriteException *) x));
}
static void *_p_Mezzanine__DirectoryReadExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::DirectoryException *) ((Mezzanine::DirectoryReadException *) x));
}
static void *_p_Mezzanine__DirectoryExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *)  ((Mezzanine::DirectoryException *) x));
}
static void *_p_Mezzanine__FilePermissionExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::FileException *) ((Mezzanine::FilePermissionException *) x));
}
static void *_p_Mezzanine__FileNotFoundExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::FileException *) ((Mezzanine::FileNotFoundException *) x));
}
static void *_p_Mezzanine__FileWriteExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::FileException *) ((Mezzanine::FileWriteException *) x));
}
static void *_p_Mezzanine__FileReadExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::FileException *) ((Mezzanine::FileReadException *) x));
}
static void *_p_Mezzanine__FileExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *)  ((Mezzanine::FileException *) x));
}
static void *_p_Mezzanine__NetworkURLExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::NetworkException *) ((Mezzanine::NetworkURLException *) x));
}
static void *_p_Mezzanine__NetworkPermissionExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *) (Mezzanine::NetworkException *) ((Mezzanine::NetworkPermissionException *) x));
}
static void *_p_Mezzanine__IOWriteExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *)  ((Mezzanine::IOWriteException *) x));
}
static void *_p_Mezzanine__IOReadExceptionTo_p_Mezzanine__IOException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::IOException *)  ((Mezzanine::IOReadException *) x));
}
static void *_p_Mezzanine__FileReadExceptionTo_p_Mezzanine__FileException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::FileException *)  ((Mezzanine::FileReadException *) x));
}
static void *_p_Mezzanine__FileWriteExceptionTo_p_Mezzanine__FileException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::FileException *)  ((Mezzanine::FileWriteException *) x));
}
static void *_p_Mezzanine__FileNotFoundExceptionTo_p_Mezzanine__FileException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::FileException *)  ((Mezzanine::FileNotFoundException *) x));
}
static void *_p_Mezzanine__FilePermissionExceptionTo_p_Mezzanine__FileException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::FileException *)  ((Mezzanine::FilePermissionException *) x));
}
static void *_p_Mezzanine__DirectoryReadExceptionTo_p_Mezzanine__DirectoryException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::DirectoryException *)  ((Mezzanine::DirectoryReadException *) x));
}
static void *_p_Mezzanine__DirectoryWriteExceptionTo_p_Mezzanine__DirectoryException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::DirectoryException *)  ((Mezzanine::DirectoryWriteException *) x));
}
static void *_p_Mezzanine__DirectoryNotFoundExceptionTo_p_Mezzanine__DirectoryException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::DirectoryException *)  ((Mezzanine::DirectoryNotFoundException *) x));
}
static void *_p_Mezzanine__DirectoryPermissionExceptionTo_p_Mezzanine__DirectoryException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::DirectoryException *)  ((Mezzanine::DirectoryPermissionException *) x));
}
static void *_p_Mezzanine__NetworkReadExceptionTo_p_Mezzanine__NetworkException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::NetworkException *)  ((Mezzanine::NetworkReadException *) x));
}
static void *_p_Mezzanine__NetworkWriteExceptionTo_p_Mezzanine__NetworkException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::NetworkException *)  ((Mezzanine::NetworkWriteException *) x));
}
static void *_p_Mezzanine__NetworkNotFoundExceptionTo_p_Mezzanine__NetworkException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::NetworkException *)  ((Mezzanine::NetworkNotFoundException *) x));
}
static void *_p_Mezzanine__NetworkURLExceptionTo_p_Mezzanine__NetworkException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::NetworkException *)  ((Mezzanine::NetworkURLException *) x));
}
static void *_p_Mezzanine__NetworkPermissionExceptionTo_p_Mezzanine__NetworkException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::NetworkException *)  ((Mezzanine::NetworkPermissionException *) x));
}
static void *_p_Mezzanine__InstanceIdentityInvalidExceptionTo_p_Mezzanine__InstanceIdentityException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::InstanceIdentityException *)  ((Mezzanine::InstanceIdentityInvalidException *) x));
}
static void *_p_Mezzanine__InstanceIdentityNotFoundExceptionTo_p_Mezzanine__InstanceIdentityException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::InstanceIdentityException *)  ((Mezzanine::InstanceIdentityNotFoundException *) x));
}
static void *_p_Mezzanine__InstanceIdentityDuplicateExceptionTo_p_Mezzanine__InstanceIdentityException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::InstanceIdentityException *)  ((Mezzanine::InstanceIdentityDuplicateException *) x));
}
static void *_p_Mezzanine__OutOfMemoryExceptionTo_p_Mezzanine__MemoryManagementException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::MemoryManagementException *)  ((Mezzanine::OutOfMemoryException *) x));
}
static void *_p_Mezzanine__MemoryOutOfBoundsExceptionTo_p_Mezzanine__MemoryManagementException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::MemoryManagementException *)  ((Mezzanine::MemoryOutOfBoundsException *) x));
}
static void *_p_Mezzanine__SyntaxErrorXMLExceptionTo_p_Mezzanine__SyntaxErrorException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::SyntaxErrorException *)  ((Mezzanine::SyntaxErrorXMLException *) x));
}
static void *_p_Mezzanine__SyntaxErrorXPathExceptionTo_p_Mezzanine__SyntaxErrorException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::SyntaxErrorException *)  ((Mezzanine::SyntaxErrorXPathException *) x));
}
static void *_p_Mezzanine__SyntaxErrorLuaExceptionTo_p_Mezzanine__SyntaxErrorException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::SyntaxErrorException *)  ((Mezzanine::SyntaxErrorLuaException *) x));
}
static void *_p_Mezzanine__ScriptLuaExceptionTo_p_Mezzanine__ScriptException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptException *)  ((Mezzanine::ScriptLuaException *) x));
}
static void *_p_Mezzanine__ScriptLuaYieldExceptionTo_p_Mezzanine__ScriptException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptException *) (Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaYieldException *) x));
}
static void *_p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_Mezzanine__ScriptException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptException *) (Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaRuntimeException *) x));
}
static void *_p_Mezzanine__ScriptLuaErrErrExceptionTo_p_Mezzanine__ScriptException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptException *) (Mezzanine::ScriptLuaException *) ((Mezzanine::ScriptLuaErrErrException *) x));
}
static void *_p_Mezzanine__ScriptLuaYieldExceptionTo_p_Mezzanine__ScriptLuaException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptLuaException *)  ((Mezzanine::ScriptLuaYieldException *) x));
}
static void *_p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_Mezzanine__ScriptLuaException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptLuaException *)  ((Mezzanine::ScriptLuaRuntimeException *) x));
}
static void *_p_Mezzanine__ScriptLuaErrErrExceptionTo_p_Mezzanine__ScriptLuaException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ScriptLuaException *)  ((Mezzanine::ScriptLuaErrErrException *) x));
}
static void *_p_Mezzanine__ParametersCastExceptionTo_p_Mezzanine__ParametersException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ParametersException *)  ((Mezzanine::ParametersCastException *) x));
}
static void *_p_Mezzanine__ParametersRangeExceptionTo_p_Mezzanine__ParametersException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::ParametersException *)  ((Mezzanine::ParametersRangeException *) x));
}
static void *_p_Mezzanine__Physics__GhostProxyTo_p_Mezzanine__Physics__CollidableProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollidableProxy *)  ((Mezzanine::Physics::GhostProxy *) x));
}
static void *_p_Mezzanine__Physics__SoftProxyTo_p_Mezzanine__Physics__CollidableProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollidableProxy *)  ((Mezzanine::Physics::SoftProxy *) x));
}
static void *_p_Mezzanine__Physics__RigidProxyTo_p_Mezzanine__Physics__CollidableProxy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Mezzanine::Physics::CollidableProxy *)  ((Mezzanine::Physics::RigidProxy *) x));
}
static swig_type_info _swigt__p_AxisAlignedBox = {"_p_AxisAlignedBox", "AxisAlignedBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AxisList = {"_p_AxisList", "AxisList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChannelType = {"_p_ChannelType", "ChannelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CollidablePair = {"_p_CollidablePair", "CollidablePair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CollisionContainer = {"_p_CollisionContainer", "CollisionContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CollisionIterator = {"_p_CollisionIterator", "CollisionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CollisionShapeManager = {"_p_CollisionShapeManager", "CollisionShapeManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CollisionSortPair = {"_p_CollisionSortPair", "CollisionSortPair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstCollisionIterator = {"_p_ConstCollisionIterator", "ConstCollisionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstConstraintIterator = {"_p_ConstConstraintIterator", "ConstConstraintIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstProxyIterator = {"_p_ConstProxyIterator", "ConstProxyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstShapeMapIterator = {"_p_ConstShapeMapIterator", "ConstShapeMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstShapeVectorIterator = {"_p_ConstShapeVectorIterator", "ConstShapeVectorIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstWorldTriggerIterator = {"_p_ConstWorldTriggerIterator", "ConstWorldTriggerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstraintContainer = {"_p_ConstraintContainer", "ConstraintContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstraintIterator = {"_p_ConstraintIterator", "ConstraintIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ManagerBase = {"_p_ManagerBase", "ManagerBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ManagerBase__ManagerType = {"_p_ManagerBase__ManagerType", "ManagerBase::ManagerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ManagerConstructionInfo = {"_p_ManagerConstructionInfo", "ManagerConstructionInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__ArithmeticException = {"_p_Mezzanine__ArithmeticException", "Mezzanine::ArithmeticException *", 0, 0, (void*)&_wrap_class_Mezzanine_ArithmeticException, 0};
static swig_type_info _swigt__p_Mezzanine__AxisAlignedBox = {"_p_Mezzanine__AxisAlignedBox", "Mezzanine::AxisAlignedBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__DirectoryException = {"_p_Mezzanine__DirectoryException", "Mezzanine::DirectoryException *", 0, 0, (void*)&_wrap_class_Mezzanine_DirectoryException, 0};
static swig_type_info _swigt__p_Mezzanine__DirectoryNotFoundException = {"_p_Mezzanine__DirectoryNotFoundException", "Mezzanine::DirectoryNotFoundException *", 0, 0, (void*)&_wrap_class_Mezzanine_DirectoryNotFoundException, 0};
static swig_type_info _swigt__p_Mezzanine__DirectoryPermissionException = {"_p_Mezzanine__DirectoryPermissionException", "Mezzanine::DirectoryPermissionException *", 0, 0, (void*)&_wrap_class_Mezzanine_DirectoryPermissionException, 0};
static swig_type_info _swigt__p_Mezzanine__DirectoryReadException = {"_p_Mezzanine__DirectoryReadException", "Mezzanine::DirectoryReadException *", 0, 0, (void*)&_wrap_class_Mezzanine_DirectoryReadException, 0};
static swig_type_info _swigt__p_Mezzanine__DirectoryWriteException = {"_p_Mezzanine__DirectoryWriteException", "Mezzanine::DirectoryWriteException *", 0, 0, (void*)&_wrap_class_Mezzanine_DirectoryWriteException, 0};
static swig_type_info _swigt__p_Mezzanine__Exception = {"_p_Mezzanine__Exception", "Mezzanine::Exception *", 0, 0, (void*)&_wrap_class_Mezzanine_Exception, 0};
static swig_type_info _swigt__p_Mezzanine__FileException = {"_p_Mezzanine__FileException", "Mezzanine::FileException *", 0, 0, (void*)&_wrap_class_Mezzanine_FileException, 0};
static swig_type_info _swigt__p_Mezzanine__FileNotFoundException = {"_p_Mezzanine__FileNotFoundException", "Mezzanine::FileNotFoundException *", 0, 0, (void*)&_wrap_class_Mezzanine_FileNotFoundException, 0};
static swig_type_info _swigt__p_Mezzanine__FilePermissionException = {"_p_Mezzanine__FilePermissionException", "Mezzanine::FilePermissionException *", 0, 0, (void*)&_wrap_class_Mezzanine_FilePermissionException, 0};
static swig_type_info _swigt__p_Mezzanine__FileReadException = {"_p_Mezzanine__FileReadException", "Mezzanine::FileReadException *", 0, 0, (void*)&_wrap_class_Mezzanine_FileReadException, 0};
static swig_type_info _swigt__p_Mezzanine__FileWriteException = {"_p_Mezzanine__FileWriteException", "Mezzanine::FileWriteException *", 0, 0, (void*)&_wrap_class_Mezzanine_FileWriteException, 0};
static swig_type_info _swigt__p_Mezzanine__Graphics__Mesh = {"_p_Mezzanine__Graphics__Mesh", "Mezzanine::Graphics::Mesh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__IOException = {"_p_Mezzanine__IOException", "Mezzanine::IOException *", 0, 0, (void*)&_wrap_class_Mezzanine_IOException, 0};
static swig_type_info _swigt__p_Mezzanine__IOReadException = {"_p_Mezzanine__IOReadException", "Mezzanine::IOReadException *", 0, 0, (void*)&_wrap_class_Mezzanine_IOReadException, 0};
static swig_type_info _swigt__p_Mezzanine__IOWriteException = {"_p_Mezzanine__IOWriteException", "Mezzanine::IOWriteException *", 0, 0, (void*)&_wrap_class_Mezzanine_IOWriteException, 0};
static swig_type_info _swigt__p_Mezzanine__InstanceIdentityDuplicateException = {"_p_Mezzanine__InstanceIdentityDuplicateException", "Mezzanine::InstanceIdentityDuplicateException *", 0, 0, (void*)&_wrap_class_Mezzanine_InstanceIdentityDuplicateException, 0};
static swig_type_info _swigt__p_Mezzanine__InstanceIdentityException = {"_p_Mezzanine__InstanceIdentityException", "Mezzanine::InstanceIdentityException *", 0, 0, (void*)&_wrap_class_Mezzanine_InstanceIdentityException, 0};
static swig_type_info _swigt__p_Mezzanine__InstanceIdentityInvalidException = {"_p_Mezzanine__InstanceIdentityInvalidException", "Mezzanine::InstanceIdentityInvalidException *", 0, 0, (void*)&_wrap_class_Mezzanine_InstanceIdentityInvalidException, 0};
static swig_type_info _swigt__p_Mezzanine__InstanceIdentityNotFoundException = {"_p_Mezzanine__InstanceIdentityNotFoundException", "Mezzanine::InstanceIdentityNotFoundException *", 0, 0, (void*)&_wrap_class_Mezzanine_InstanceIdentityNotFoundException, 0};
static swig_type_info _swigt__p_Mezzanine__InternalException = {"_p_Mezzanine__InternalException", "Mezzanine::InternalException *", 0, 0, (void*)&_wrap_class_Mezzanine_InternalException, 0};
static swig_type_info _swigt__p_Mezzanine__InvalidAssignment = {"_p_Mezzanine__InvalidAssignment", "Mezzanine::InvalidAssignment *", 0, 0, (void*)&_wrap_class_Mezzanine_InvalidAssignment, 0};
static swig_type_info _swigt__p_Mezzanine__InvalidStateException = {"_p_Mezzanine__InvalidStateException", "Mezzanine::InvalidStateException *", 0, 0, (void*)&_wrap_class_Mezzanine_InvalidStateException, 0};
static swig_type_info _swigt__p_Mezzanine__InvalidVersionException = {"_p_Mezzanine__InvalidVersionException", "Mezzanine::InvalidVersionException *", 0, 0, (void*)&_wrap_class_Mezzanine_InvalidVersionException, 0};
static swig_type_info _swigt__p_Mezzanine__Matrix3x3 = {"_p_Mezzanine__Matrix3x3", "Mezzanine::Matrix3x3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__MemoryManagementException = {"_p_Mezzanine__MemoryManagementException", "Mezzanine::MemoryManagementException *", 0, 0, (void*)&_wrap_class_Mezzanine_MemoryManagementException, 0};
static swig_type_info _swigt__p_Mezzanine__MemoryOutOfBoundsException = {"_p_Mezzanine__MemoryOutOfBoundsException", "Mezzanine::MemoryOutOfBoundsException *", 0, 0, (void*)&_wrap_class_Mezzanine_MemoryOutOfBoundsException, 0};
static swig_type_info _swigt__p_Mezzanine__NetworkException = {"_p_Mezzanine__NetworkException", "Mezzanine::NetworkException *", 0, 0, (void*)&_wrap_class_Mezzanine_NetworkException, 0};
static swig_type_info _swigt__p_Mezzanine__NetworkNotFoundException = {"_p_Mezzanine__NetworkNotFoundException", "Mezzanine::NetworkNotFoundException *", 0, 0, (void*)&_wrap_class_Mezzanine_NetworkNotFoundException, 0};
static swig_type_info _swigt__p_Mezzanine__NetworkPermissionException = {"_p_Mezzanine__NetworkPermissionException", "Mezzanine::NetworkPermissionException *", 0, 0, (void*)&_wrap_class_Mezzanine_NetworkPermissionException, 0};
static swig_type_info _swigt__p_Mezzanine__NetworkReadException = {"_p_Mezzanine__NetworkReadException", "Mezzanine::NetworkReadException *", 0, 0, (void*)&_wrap_class_Mezzanine_NetworkReadException, 0};
static swig_type_info _swigt__p_Mezzanine__NetworkURLException = {"_p_Mezzanine__NetworkURLException", "Mezzanine::NetworkURLException *", 0, 0, (void*)&_wrap_class_Mezzanine_NetworkURLException, 0};
static swig_type_info _swigt__p_Mezzanine__NetworkWriteException = {"_p_Mezzanine__NetworkWriteException", "Mezzanine::NetworkWriteException *", 0, 0, (void*)&_wrap_class_Mezzanine_NetworkWriteException, 0};
static swig_type_info _swigt__p_Mezzanine__NotImplementedException = {"_p_Mezzanine__NotImplementedException", "Mezzanine::NotImplementedException *", 0, 0, (void*)&_wrap_class_Mezzanine_NotImplementedException, 0};
static swig_type_info _swigt__p_Mezzanine__OutOfMemoryException = {"_p_Mezzanine__OutOfMemoryException", "Mezzanine::OutOfMemoryException *", 0, 0, (void*)&_wrap_class_Mezzanine_OutOfMemoryException, 0};
static swig_type_info _swigt__p_Mezzanine__ParametersCastException = {"_p_Mezzanine__ParametersCastException", "Mezzanine::ParametersCastException *", 0, 0, (void*)&_wrap_class_Mezzanine_ParametersCastException, 0};
static swig_type_info _swigt__p_Mezzanine__ParametersException = {"_p_Mezzanine__ParametersException", "Mezzanine::ParametersException *", 0, 0, (void*)&_wrap_class_Mezzanine_ParametersException, 0};
static swig_type_info _swigt__p_Mezzanine__ParametersRangeException = {"_p_Mezzanine__ParametersRangeException", "Mezzanine::ParametersRangeException *", 0, 0, (void*)&_wrap_class_Mezzanine_ParametersRangeException, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__BoxCollisionShape = {"_p_Mezzanine__Physics__BoxCollisionShape", "Mezzanine::Physics::BoxCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_BoxCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CapsuleCollisionShape = {"_p_Mezzanine__Physics__CapsuleCollisionShape", "Mezzanine::Physics::CapsuleCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CapsuleCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CollidablePair = {"_p_Mezzanine__Physics__CollidablePair", "Mezzanine::Physics::CollidablePair *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CollidablePair, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CollidableProxy = {"_p_Mezzanine__Physics__CollidableProxy", "Mezzanine::Physics::CollidableProxy *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CollidableProxy, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__Collision = {"_p_Mezzanine__Physics__Collision", "Mezzanine::Physics::Collision *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_Collision, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CollisionShape = {"_p_Mezzanine__Physics__CollisionShape", "Mezzanine::Physics::CollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CollisionShapeDeSerializer = {"_p_Mezzanine__Physics__CollisionShapeDeSerializer", "Mezzanine::Physics::CollisionShapeDeSerializer *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CollisionShapeDeSerializer, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CollisionShapeManager = {"_p_Mezzanine__Physics__CollisionShapeManager", "Mezzanine::Physics::CollisionShapeManager *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CollisionShapeManager, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator = {"_p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator", "Mezzanine::Physics::CollisionShapeManager::ShapeMap::iterator *|Mezzanine::Physics::CollisionShapeManager::ShapeMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CompoundCollisionShape = {"_p_Mezzanine__Physics__CompoundCollisionShape", "Mezzanine::Physics::CompoundCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CompoundCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__ConeCollisionShape = {"_p_Mezzanine__Physics__ConeCollisionShape", "Mezzanine::Physics::ConeCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_ConeCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__Constraint = {"_p_Mezzanine__Physics__Constraint", "Mezzanine::Physics::Constraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_Constraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__ConvexHullCollisionShape = {"_p_Mezzanine__Physics__ConvexHullCollisionShape", "Mezzanine::Physics::ConvexHullCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_ConvexHullCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__CylinderCollisionShape = {"_p_Mezzanine__Physics__CylinderCollisionShape", "Mezzanine::Physics::CylinderCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_CylinderCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__DebugDrawWorkUnit = {"_p_Mezzanine__Physics__DebugDrawWorkUnit", "Mezzanine::Physics::DebugDrawWorkUnit *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_DebugDrawWorkUnit, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory = {"_p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory", "Mezzanine::Physics::DefaultCollisionShapeManagerFactory *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_DefaultCollisionShapeManagerFactory, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__DefaultPhysicsManagerFactory = {"_p_Mezzanine__Physics__DefaultPhysicsManagerFactory", "Mezzanine::Physics::DefaultPhysicsManagerFactory *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_DefaultPhysicsManagerFactory, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__DualTransformConstraint = {"_p_Mezzanine__Physics__DualTransformConstraint", "Mezzanine::Physics::DualTransformConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_DualTransformConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__DynamicMeshCollisionShape = {"_p_Mezzanine__Physics__DynamicMeshCollisionShape", "Mezzanine::Physics::DynamicMeshCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_DynamicMeshCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__FieldCollisionShape = {"_p_Mezzanine__Physics__FieldCollisionShape", "Mezzanine::Physics::FieldCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_FieldCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__GearConstraint = {"_p_Mezzanine__Physics__GearConstraint", "Mezzanine::Physics::GearConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_GearConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__Generic6DofConstraint = {"_p_Mezzanine__Physics__Generic6DofConstraint", "Mezzanine::Physics::Generic6DofConstraint *|Mezzanine::Physics::StickyConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_Generic6DofConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__Generic6DofSpringConstraint = {"_p_Mezzanine__Physics__Generic6DofSpringConstraint", "Mezzanine::Physics::Generic6DofSpringConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_Generic6DofSpringConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__GhostProxy = {"_p_Mezzanine__Physics__GhostProxy", "Mezzanine::Physics::GhostProxy *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_GhostProxy, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__HeightfieldCollisionShape = {"_p_Mezzanine__Physics__HeightfieldCollisionShape", "Mezzanine::Physics::HeightfieldCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_HeightfieldCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__HingeConstraint = {"_p_Mezzanine__Physics__HingeConstraint", "Mezzanine::Physics::HingeConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_HingeConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__ManagerConstructionInfo = {"_p_Mezzanine__Physics__ManagerConstructionInfo", "Mezzanine::Physics::ManagerConstructionInfo *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_ManagerConstructionInfo, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__MeshCollisionShape = {"_p_Mezzanine__Physics__MeshCollisionShape", "Mezzanine::Physics::MeshCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_MeshCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__MultiSphereCollisionShape = {"_p_Mezzanine__Physics__MultiSphereCollisionShape", "Mezzanine::Physics::MultiSphereCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_MultiSphereCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__PhysicsManager = {"_p_Mezzanine__Physics__PhysicsManager", "Mezzanine::Physics::PhysicsManager *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_PhysicsManager, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator = {"_p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator", "Mezzanine::Physics::PhysicsManager::CollisionIterator *|Mezzanine::Physics::PhysicsManager::CollisionContainer::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__PlaneCollisionShape = {"_p_Mezzanine__Physics__PlaneCollisionShape", "Mezzanine::Physics::PlaneCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_PlaneCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__Point2PointConstraint = {"_p_Mezzanine__Physics__Point2PointConstraint", "Mezzanine::Physics::Point2PointConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_Point2PointConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__PrimitiveCollisionShape = {"_p_Mezzanine__Physics__PrimitiveCollisionShape", "Mezzanine::Physics::PrimitiveCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_PrimitiveCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__RigidProxy = {"_p_Mezzanine__Physics__RigidProxy", "Mezzanine::Physics::RigidProxy *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_RigidProxy, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__SimulationMonopolyWorkUnit = {"_p_Mezzanine__Physics__SimulationMonopolyWorkUnit", "Mezzanine::Physics::SimulationMonopolyWorkUnit *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_SimulationMonopolyWorkUnit, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__SimulationWorkUnit = {"_p_Mezzanine__Physics__SimulationWorkUnit", "Mezzanine::Physics::SimulationWorkUnit *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_SimulationWorkUnit, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__SliderConstraint = {"_p_Mezzanine__Physics__SliderConstraint", "Mezzanine::Physics::SliderConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_SliderConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__SoftCollisionShape = {"_p_Mezzanine__Physics__SoftCollisionShape", "Mezzanine::Physics::SoftCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_SoftCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__SoftProxy = {"_p_Mezzanine__Physics__SoftProxy", "Mezzanine::Physics::SoftProxy *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_SoftProxy, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__SphereCollisionShape = {"_p_Mezzanine__Physics__SphereCollisionShape", "Mezzanine::Physics::SphereCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_SphereCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__StaticMeshCollisionShape = {"_p_Mezzanine__Physics__StaticMeshCollisionShape", "Mezzanine::Physics::StaticMeshCollisionShape *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_StaticMeshCollisionShape, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__StickyConstraintConstructionInfo = {"_p_Mezzanine__Physics__StickyConstraintConstructionInfo", "Mezzanine::Physics::StickyConstraintConstructionInfo *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_StickyConstraintConstructionInfo, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__StickyData = {"_p_Mezzanine__Physics__StickyData", "Mezzanine::Physics::StickyData *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_StickyData, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__UniversalConstraint = {"_p_Mezzanine__Physics__UniversalConstraint", "Mezzanine::Physics::UniversalConstraint *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_UniversalConstraint, 0};
static swig_type_info _swigt__p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit = {"_p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit", "Mezzanine::Physics::WorldTriggerUpdateWorkUnit *", 0, 0, (void*)&_wrap_class_Mezzanine_Physics_WorldTriggerUpdateWorkUnit, 0};
static swig_type_info _swigt__p_Mezzanine__Plane = {"_p_Mezzanine__Plane", "Mezzanine::Plane *", 0, 0, (void*)&_wrap_class_Mezzanine_Plane, 0};
static swig_type_info _swigt__p_Mezzanine__Quaternion = {"_p_Mezzanine__Quaternion", "Mezzanine::Quaternion *", 0, 0, (void*)&_wrap_class_Mezzanine_Quaternion, 0};
static swig_type_info _swigt__p_Mezzanine__Ray = {"_p_Mezzanine__Ray", "Mezzanine::Ray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__RenderingAPIException = {"_p_Mezzanine__RenderingAPIException", "Mezzanine::RenderingAPIException *", 0, 0, (void*)&_wrap_class_Mezzanine_RenderingAPIException, 0};
static swig_type_info _swigt__p_Mezzanine__RuntimeAssertionException = {"_p_Mezzanine__RuntimeAssertionException", "Mezzanine::RuntimeAssertionException *", 0, 0, (void*)&_wrap_class_Mezzanine_RuntimeAssertionException, 0};
static swig_type_info _swigt__p_Mezzanine__ScriptException = {"_p_Mezzanine__ScriptException", "Mezzanine::ScriptException *", 0, 0, (void*)&_wrap_class_Mezzanine_ScriptException, 0};
static swig_type_info _swigt__p_Mezzanine__ScriptLuaErrErrException = {"_p_Mezzanine__ScriptLuaErrErrException", "Mezzanine::ScriptLuaErrErrException *", 0, 0, (void*)&_wrap_class_Mezzanine_ScriptLuaErrErrException, 0};
static swig_type_info _swigt__p_Mezzanine__ScriptLuaException = {"_p_Mezzanine__ScriptLuaException", "Mezzanine::ScriptLuaException *", 0, 0, (void*)&_wrap_class_Mezzanine_ScriptLuaException, 0};
static swig_type_info _swigt__p_Mezzanine__ScriptLuaRuntimeException = {"_p_Mezzanine__ScriptLuaRuntimeException", "Mezzanine::ScriptLuaRuntimeException *", 0, 0, (void*)&_wrap_class_Mezzanine_ScriptLuaRuntimeException, 0};
static swig_type_info _swigt__p_Mezzanine__ScriptLuaYieldException = {"_p_Mezzanine__ScriptLuaYieldException", "Mezzanine::ScriptLuaYieldException *", 0, 0, (void*)&_wrap_class_Mezzanine_ScriptLuaYieldException, 0};
static swig_type_info _swigt__p_Mezzanine__SingletonT_CollisionShapeManager_t = {"_p_Mezzanine__SingletonT_CollisionShapeManager_t", "Mezzanine::Singleton< CollisionShapeManager > *", 0, 0, (void*)&_wrap_class_Mezzanine_Singleton_Sl_CollisionShapeManager_Sg_, 0};
static swig_type_info _swigt__p_Mezzanine__Sphere = {"_p_Mezzanine__Sphere", "Mezzanine::Sphere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__SyntaxErrorException = {"_p_Mezzanine__SyntaxErrorException", "Mezzanine::SyntaxErrorException *", 0, 0, (void*)&_wrap_class_Mezzanine_SyntaxErrorException, 0};
static swig_type_info _swigt__p_Mezzanine__SyntaxErrorLuaException = {"_p_Mezzanine__SyntaxErrorLuaException", "Mezzanine::SyntaxErrorLuaException *", 0, 0, (void*)&_wrap_class_Mezzanine_SyntaxErrorLuaException, 0};
static swig_type_info _swigt__p_Mezzanine__SyntaxErrorXMLException = {"_p_Mezzanine__SyntaxErrorXMLException", "Mezzanine::SyntaxErrorXMLException *", 0, 0, (void*)&_wrap_class_Mezzanine_SyntaxErrorXMLException, 0};
static swig_type_info _swigt__p_Mezzanine__SyntaxErrorXPathException = {"_p_Mezzanine__SyntaxErrorXPathException", "Mezzanine::SyntaxErrorXPathException *", 0, 0, (void*)&_wrap_class_Mezzanine_SyntaxErrorXPathException, 0};
static swig_type_info _swigt__p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type = {"_p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type", "Mezzanine::Threading::DefaultThreadSpecificStorage::Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__Threading__DefaultWorkUnit = {"_p_Mezzanine__Threading__DefaultWorkUnit", "Mezzanine::Threading::DefaultWorkUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__Threading__RawFile = {"_p_Mezzanine__Threading__RawFile", "Mezzanine::Threading::RawFile *|Mezzanine::RawFile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__Transform = {"_p_Mezzanine__Transform", "Mezzanine::Transform *", 0, 0, (void*)&_wrap_class_Mezzanine_Transform, 0};
static swig_type_info _swigt__p_Mezzanine__TransformableChildObject = {"_p_Mezzanine__TransformableChildObject", "Mezzanine::TransformableChildObject *", 0, 0, (void*)&_wrap_class_Mezzanine_TransformableChildObject, 0};
static swig_type_info _swigt__p_Mezzanine__TransformableObject = {"_p_Mezzanine__TransformableObject", "Mezzanine::TransformableObject *", 0, 0, (void*)&_wrap_class_Mezzanine_TransformableObject, 0};
static swig_type_info _swigt__p_Mezzanine__Vector3 = {"_p_Mezzanine__Vector3", "Mezzanine::Vector3 *|Mezzanine::Physics::Vector3 *", 0, 0, (void*)&_wrap_class_Mezzanine_Vector3, 0};
static swig_type_info _swigt__p_Mezzanine__WorldManager = {"_p_Mezzanine__WorldManager", "Mezzanine::WorldManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__WorldObject = {"_p_Mezzanine__WorldObject", "Mezzanine::WorldObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mezzanine__WorldProxy = {"_p_Mezzanine__WorldProxy", "Mezzanine::WorldProxy *", 0, 0, (void*)&_wrap_class_Mezzanine_WorldProxy, 0};
static swig_type_info _swigt__p_Mezzanine__WorldTrigger = {"_p_Mezzanine__WorldTrigger", "Mezzanine::WorldTrigger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Plane = {"_p_Ogre__Plane", "Ogre::Plane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Quaternion = {"_p_Ogre__Quaternion", "Ogre::Quaternion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Vector3 = {"_p_Ogre__Vector3", "Ogre::Vector3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParamList = {"_p_ParamList", "ParamList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ProxyContainer = {"_p_ProxyContainer", "ProxyContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ProxyIterator = {"_p_ProxyIterator", "ProxyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RayTestResult = {"_p_RayTestResult", "RayTestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SDL_Event = {"_p_SDL_Event", "SDL_Event *|Mezzanine::RawEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShapeMap = {"_p_ShapeMap", "ShapeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShapeMapIterator = {"_p_ShapeMapIterator", "ShapeMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShapeVector = {"_p_ShapeVector", "ShapeVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShapeVectorIterator = {"_p_ShapeVectorIterator", "ShapeVectorIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StandardAxis = {"_p_StandardAxis", "StandardAxis *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Transform = {"_p_Transform", "Transform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_WorldTriggerContainer = {"_p_WorldTriggerContainer", "WorldTriggerContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_WorldTriggerIterator = {"_p_WorldTriggerIterator", "WorldTriggerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XML__Node = {"_p_XML__Node", "XML::Node *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *|Mezzanine::Boole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btBoxShape = {"_p_btBoxShape", "btBoxShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btBvhTriangleMeshShape = {"_p_btBvhTriangleMeshShape", "btBvhTriangleMeshShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btCapsuleShape = {"_p_btCapsuleShape", "btCapsuleShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btCollisionObject = {"_p_btCollisionObject", "btCollisionObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btCollisionShape = {"_p_btCollisionShape", "btCollisionShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btCompoundShape = {"_p_btCompoundShape", "btCompoundShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btConcaveShape = {"_p_btConcaveShape", "btConcaveShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btConeShape = {"_p_btConeShape", "btConeShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btConvexHullShape = {"_p_btConvexHullShape", "btConvexHullShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btConvexInternalShape = {"_p_btConvexInternalShape", "btConvexInternalShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btCylinderShape = {"_p_btCylinderShape", "btCylinderShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btGImpactMeshShape = {"_p_btGImpactMeshShape", "btGImpactMeshShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btHeightfieldTerrainShape = {"_p_btHeightfieldTerrainShape", "btHeightfieldTerrainShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btMultiSphereShape = {"_p_btMultiSphereShape", "btMultiSphereShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btPairCachingGhostObject = {"_p_btPairCachingGhostObject", "btPairCachingGhostObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btQuaternion = {"_p_btQuaternion", "btQuaternion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btRigidBody = {"_p_btRigidBody", "btRigidBody *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btSoftBody = {"_p_btSoftBody", "btSoftBody *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btSoftBodyCollisionShape = {"_p_btSoftBodyCollisionShape", "btSoftBodyCollisionShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btSphereShape = {"_p_btSphereShape", "btSphereShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btStaticPlaneShape = {"_p_btStaticPlaneShape", "btStaticPlaneShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btTransform = {"_p_btTransform", "btTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btTypedConstraint = {"_p_btTypedConstraint", "btTypedConstraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_btVector3 = {"_p_btVector3", "btVector3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *|Mezzanine::Char8 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "Mezzanine::PreciseReal *|double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *|btScalar *|Mezzanine::Real *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|Mezzanine::Int32 *|int32_t *|Mezzanine::ConvertiblePointer *|Mezzanine::Integer *|int_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|Mezzanine::Int64 *|int64_t *|long long *|Mezzanine::MaxInt *|intmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "Mezzanine::Int16 *|short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|Mezzanine::Int8 *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_std__pairT_std__string_std__string_t_t = {"_p_std__listT_std__pairT_std__string_std__string_t_t", "Mezzanine::NameValuePairList *|std::list< std::pair< std::string,std::string > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_std__string_t = {"_p_std__mapT_std__string_std__string_t", "Mezzanine::NameValuePairMap *|std::map< std::string,std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_bool_Mezzanine__Vector3_t = {"_p_std__pairT_bool_Mezzanine__Vector3_t", "Mezzanine::Plane::RayTestResult *|std::pair< bool,Mezzanine::Vector3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_std__string_t = {"_p_std__pairT_std__string_std__string_t", "Mezzanine::NameValuePair *|std::pair< std::string,std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_std__string_t = {"_p_std__setT_std__string_t", "std::set< std::string > *|Mezzanine::StringSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *|Mezzanine::String *|Mezzanine::ConstString *", 0, 0, (void*)&_wrap_class_std_string, 0};
static swig_type_info _swigt__p_std__stringstream = {"_p_std__stringstream", "Mezzanine::Logger *|std::stringstream *|Mezzanine::StringStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t = {"_p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t", "Mezzanine::Physics::CollisionShapeManager::ShapeVector *|std::vector< Mezzanine::Physics::CollisionShape * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Mezzanine__Physics__ConstraintParam_t = {"_p_std__vectorT_Mezzanine__Physics__ConstraintParam_t", "Mezzanine::Physics::Constraint::ParamList *|std::vector< enum Mezzanine::Physics::ConstraintParam > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t = {"_p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t", "std::vector< Mezzanine::Physics::StickyConstraint * > *|std::vector< Mezzanine::Physics::Generic6DofConstraint * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t = {"_p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t", "std::vector< Mezzanine::Physics::StickyConstraintConstructionInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Mezzanine__Vector3_t = {"_p_std__vectorT_Mezzanine__Vector3_t", "std::vector< Mezzanine::Vector3 > *|std::vector< Mezzanine::Physics::Vector3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_float_t = {"_p_std__vectorT_float_t", "std::vector< float > *|std::vector< Mezzanine::Real > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "Mezzanine::Physics::Constraint::AxisList *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *|Mezzanine::StringVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__wstring = {"_p_std__wstring", "std::wstring *|Mezzanine::WideString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|Mezzanine::UInt8 *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|Mezzanine::UInt32 *|unsigned int *|Mezzanine::TimeMarker *|uint_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Mezzanine::Whole *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|Mezzanine::UInt64 *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "Mezzanine::UInt16 *|unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_AxisAlignedBox,
  &_swigt__p_AxisList,
  &_swigt__p_ChannelType,
  &_swigt__p_CollidablePair,
  &_swigt__p_CollisionContainer,
  &_swigt__p_CollisionIterator,
  &_swigt__p_CollisionShapeManager,
  &_swigt__p_CollisionSortPair,
  &_swigt__p_ConstCollisionIterator,
  &_swigt__p_ConstConstraintIterator,
  &_swigt__p_ConstProxyIterator,
  &_swigt__p_ConstShapeMapIterator,
  &_swigt__p_ConstShapeVectorIterator,
  &_swigt__p_ConstWorldTriggerIterator,
  &_swigt__p_ConstraintContainer,
  &_swigt__p_ConstraintIterator,
  &_swigt__p_ManagerBase,
  &_swigt__p_ManagerBase__ManagerType,
  &_swigt__p_ManagerConstructionInfo,
  &_swigt__p_Mezzanine__ArithmeticException,
  &_swigt__p_Mezzanine__AxisAlignedBox,
  &_swigt__p_Mezzanine__DirectoryException,
  &_swigt__p_Mezzanine__DirectoryNotFoundException,
  &_swigt__p_Mezzanine__DirectoryPermissionException,
  &_swigt__p_Mezzanine__DirectoryReadException,
  &_swigt__p_Mezzanine__DirectoryWriteException,
  &_swigt__p_Mezzanine__Exception,
  &_swigt__p_Mezzanine__FileException,
  &_swigt__p_Mezzanine__FileNotFoundException,
  &_swigt__p_Mezzanine__FilePermissionException,
  &_swigt__p_Mezzanine__FileReadException,
  &_swigt__p_Mezzanine__FileWriteException,
  &_swigt__p_Mezzanine__Graphics__Mesh,
  &_swigt__p_Mezzanine__IOException,
  &_swigt__p_Mezzanine__IOReadException,
  &_swigt__p_Mezzanine__IOWriteException,
  &_swigt__p_Mezzanine__InstanceIdentityDuplicateException,
  &_swigt__p_Mezzanine__InstanceIdentityException,
  &_swigt__p_Mezzanine__InstanceIdentityInvalidException,
  &_swigt__p_Mezzanine__InstanceIdentityNotFoundException,
  &_swigt__p_Mezzanine__InternalException,
  &_swigt__p_Mezzanine__InvalidAssignment,
  &_swigt__p_Mezzanine__InvalidStateException,
  &_swigt__p_Mezzanine__InvalidVersionException,
  &_swigt__p_Mezzanine__Matrix3x3,
  &_swigt__p_Mezzanine__MemoryManagementException,
  &_swigt__p_Mezzanine__MemoryOutOfBoundsException,
  &_swigt__p_Mezzanine__NetworkException,
  &_swigt__p_Mezzanine__NetworkNotFoundException,
  &_swigt__p_Mezzanine__NetworkPermissionException,
  &_swigt__p_Mezzanine__NetworkReadException,
  &_swigt__p_Mezzanine__NetworkURLException,
  &_swigt__p_Mezzanine__NetworkWriteException,
  &_swigt__p_Mezzanine__NotImplementedException,
  &_swigt__p_Mezzanine__OutOfMemoryException,
  &_swigt__p_Mezzanine__ParametersCastException,
  &_swigt__p_Mezzanine__ParametersException,
  &_swigt__p_Mezzanine__ParametersRangeException,
  &_swigt__p_Mezzanine__Physics__BoxCollisionShape,
  &_swigt__p_Mezzanine__Physics__CapsuleCollisionShape,
  &_swigt__p_Mezzanine__Physics__CollidablePair,
  &_swigt__p_Mezzanine__Physics__CollidableProxy,
  &_swigt__p_Mezzanine__Physics__Collision,
  &_swigt__p_Mezzanine__Physics__CollisionShape,
  &_swigt__p_Mezzanine__Physics__CollisionShapeDeSerializer,
  &_swigt__p_Mezzanine__Physics__CollisionShapeManager,
  &_swigt__p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator,
  &_swigt__p_Mezzanine__Physics__CompoundCollisionShape,
  &_swigt__p_Mezzanine__Physics__ConeCollisionShape,
  &_swigt__p_Mezzanine__Physics__Constraint,
  &_swigt__p_Mezzanine__Physics__ConvexHullCollisionShape,
  &_swigt__p_Mezzanine__Physics__CylinderCollisionShape,
  &_swigt__p_Mezzanine__Physics__DebugDrawWorkUnit,
  &_swigt__p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,
  &_swigt__p_Mezzanine__Physics__DefaultPhysicsManagerFactory,
  &_swigt__p_Mezzanine__Physics__DualTransformConstraint,
  &_swigt__p_Mezzanine__Physics__DynamicMeshCollisionShape,
  &_swigt__p_Mezzanine__Physics__FieldCollisionShape,
  &_swigt__p_Mezzanine__Physics__GearConstraint,
  &_swigt__p_Mezzanine__Physics__Generic6DofConstraint,
  &_swigt__p_Mezzanine__Physics__Generic6DofSpringConstraint,
  &_swigt__p_Mezzanine__Physics__GhostProxy,
  &_swigt__p_Mezzanine__Physics__HeightfieldCollisionShape,
  &_swigt__p_Mezzanine__Physics__HingeConstraint,
  &_swigt__p_Mezzanine__Physics__ManagerConstructionInfo,
  &_swigt__p_Mezzanine__Physics__MeshCollisionShape,
  &_swigt__p_Mezzanine__Physics__MultiSphereCollisionShape,
  &_swigt__p_Mezzanine__Physics__PhysicsManager,
  &_swigt__p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator,
  &_swigt__p_Mezzanine__Physics__PlaneCollisionShape,
  &_swigt__p_Mezzanine__Physics__Point2PointConstraint,
  &_swigt__p_Mezzanine__Physics__PrimitiveCollisionShape,
  &_swigt__p_Mezzanine__Physics__RigidProxy,
  &_swigt__p_Mezzanine__Physics__SimulationMonopolyWorkUnit,
  &_swigt__p_Mezzanine__Physics__SimulationWorkUnit,
  &_swigt__p_Mezzanine__Physics__SliderConstraint,
  &_swigt__p_Mezzanine__Physics__SoftCollisionShape,
  &_swigt__p_Mezzanine__Physics__SoftProxy,
  &_swigt__p_Mezzanine__Physics__SphereCollisionShape,
  &_swigt__p_Mezzanine__Physics__StaticMeshCollisionShape,
  &_swigt__p_Mezzanine__Physics__StickyConstraintConstructionInfo,
  &_swigt__p_Mezzanine__Physics__StickyData,
  &_swigt__p_Mezzanine__Physics__UniversalConstraint,
  &_swigt__p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit,
  &_swigt__p_Mezzanine__Plane,
  &_swigt__p_Mezzanine__Quaternion,
  &_swigt__p_Mezzanine__Ray,
  &_swigt__p_Mezzanine__RenderingAPIException,
  &_swigt__p_Mezzanine__RuntimeAssertionException,
  &_swigt__p_Mezzanine__ScriptException,
  &_swigt__p_Mezzanine__ScriptLuaErrErrException,
  &_swigt__p_Mezzanine__ScriptLuaException,
  &_swigt__p_Mezzanine__ScriptLuaRuntimeException,
  &_swigt__p_Mezzanine__ScriptLuaYieldException,
  &_swigt__p_Mezzanine__SingletonT_CollisionShapeManager_t,
  &_swigt__p_Mezzanine__Sphere,
  &_swigt__p_Mezzanine__SyntaxErrorException,
  &_swigt__p_Mezzanine__SyntaxErrorLuaException,
  &_swigt__p_Mezzanine__SyntaxErrorXMLException,
  &_swigt__p_Mezzanine__SyntaxErrorXPathException,
  &_swigt__p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,
  &_swigt__p_Mezzanine__Threading__DefaultWorkUnit,
  &_swigt__p_Mezzanine__Threading__RawFile,
  &_swigt__p_Mezzanine__Transform,
  &_swigt__p_Mezzanine__TransformableChildObject,
  &_swigt__p_Mezzanine__TransformableObject,
  &_swigt__p_Mezzanine__Vector3,
  &_swigt__p_Mezzanine__WorldManager,
  &_swigt__p_Mezzanine__WorldObject,
  &_swigt__p_Mezzanine__WorldProxy,
  &_swigt__p_Mezzanine__WorldTrigger,
  &_swigt__p_Ogre__Plane,
  &_swigt__p_Ogre__Quaternion,
  &_swigt__p_Ogre__Vector3,
  &_swigt__p_ParamList,
  &_swigt__p_ProxyContainer,
  &_swigt__p_ProxyIterator,
  &_swigt__p_RayTestResult,
  &_swigt__p_SDL_Event,
  &_swigt__p_ShapeMap,
  &_swigt__p_ShapeMapIterator,
  &_swigt__p_ShapeVector,
  &_swigt__p_ShapeVectorIterator,
  &_swigt__p_StandardAxis,
  &_swigt__p_Transform,
  &_swigt__p_WorldTriggerContainer,
  &_swigt__p_WorldTriggerIterator,
  &_swigt__p_XML__Node,
  &_swigt__p_bool,
  &_swigt__p_btBoxShape,
  &_swigt__p_btBvhTriangleMeshShape,
  &_swigt__p_btCapsuleShape,
  &_swigt__p_btCollisionObject,
  &_swigt__p_btCollisionShape,
  &_swigt__p_btCompoundShape,
  &_swigt__p_btConcaveShape,
  &_swigt__p_btConeShape,
  &_swigt__p_btConvexHullShape,
  &_swigt__p_btConvexInternalShape,
  &_swigt__p_btCylinderShape,
  &_swigt__p_btGImpactMeshShape,
  &_swigt__p_btHeightfieldTerrainShape,
  &_swigt__p_btMultiSphereShape,
  &_swigt__p_btPairCachingGhostObject,
  &_swigt__p_btQuaternion,
  &_swigt__p_btRigidBody,
  &_swigt__p_btSoftBody,
  &_swigt__p_btSoftBodyCollisionShape,
  &_swigt__p_btSphereShape,
  &_swigt__p_btStaticPlaneShape,
  &_swigt__p_btTransform,
  &_swigt__p_btTypedConstraint,
  &_swigt__p_btVector3,
  &_swigt__p_char,
  &_swigt__p_double,
  &_swigt__p_float,
  &_swigt__p_int,
  &_swigt__p_long_long,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_std__exception,
  &_swigt__p_std__istream,
  &_swigt__p_std__listT_std__pairT_std__string_std__string_t_t,
  &_swigt__p_std__mapT_std__string_std__string_t,
  &_swigt__p_std__pairT_bool_Mezzanine__Vector3_t,
  &_swigt__p_std__pairT_std__string_std__string_t,
  &_swigt__p_std__setT_std__string_t,
  &_swigt__p_std__string,
  &_swigt__p_std__stringstream,
  &_swigt__p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t,
  &_swigt__p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,
  &_swigt__p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t,
  &_swigt__p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t,
  &_swigt__p_std__vectorT_Mezzanine__Vector3_t,
  &_swigt__p_std__vectorT_float_t,
  &_swigt__p_std__vectorT_int_t,
  &_swigt__p_std__vectorT_std__string_t,
  &_swigt__p_std__wstring,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
};

static swig_cast_info _swigc__p_AxisAlignedBox[] = {  {&_swigt__p_AxisAlignedBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AxisList[] = {  {&_swigt__p_AxisList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChannelType[] = {  {&_swigt__p_ChannelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CollidablePair[] = {  {&_swigt__p_CollidablePair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CollisionContainer[] = {  {&_swigt__p_CollisionContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CollisionIterator[] = {  {&_swigt__p_CollisionIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CollisionShapeManager[] = {  {&_swigt__p_CollisionShapeManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CollisionSortPair[] = {  {&_swigt__p_CollisionSortPair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstCollisionIterator[] = {  {&_swigt__p_ConstCollisionIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstConstraintIterator[] = {  {&_swigt__p_ConstConstraintIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstProxyIterator[] = {  {&_swigt__p_ConstProxyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstShapeMapIterator[] = {  {&_swigt__p_ConstShapeMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstShapeVectorIterator[] = {  {&_swigt__p_ConstShapeVectorIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstWorldTriggerIterator[] = {  {&_swigt__p_ConstWorldTriggerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstraintContainer[] = {  {&_swigt__p_ConstraintContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstraintIterator[] = {  {&_swigt__p_ConstraintIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ManagerBase[] = {  {&_swigt__p_Mezzanine__Physics__CollisionShapeManager, _p_Mezzanine__Physics__CollisionShapeManagerTo_p_ManagerBase, 0, 0},  {&_swigt__p_ManagerBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ManagerBase__ManagerType[] = {  {&_swigt__p_ManagerBase__ManagerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ManagerConstructionInfo[] = {  {&_swigt__p_ManagerConstructionInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ArithmeticException[] = {  {&_swigt__p_Mezzanine__ArithmeticException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__AxisAlignedBox[] = {  {&_swigt__p_Mezzanine__AxisAlignedBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__DirectoryException[] = {  {&_swigt__p_Mezzanine__DirectoryException, 0, 0, 0},  {&_swigt__p_Mezzanine__DirectoryReadException, _p_Mezzanine__DirectoryReadExceptionTo_p_Mezzanine__DirectoryException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryWriteException, _p_Mezzanine__DirectoryWriteExceptionTo_p_Mezzanine__DirectoryException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryNotFoundException, _p_Mezzanine__DirectoryNotFoundExceptionTo_p_Mezzanine__DirectoryException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryPermissionException, _p_Mezzanine__DirectoryPermissionExceptionTo_p_Mezzanine__DirectoryException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__DirectoryNotFoundException[] = {  {&_swigt__p_Mezzanine__DirectoryNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__DirectoryPermissionException[] = {  {&_swigt__p_Mezzanine__DirectoryPermissionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__DirectoryReadException[] = {  {&_swigt__p_Mezzanine__DirectoryReadException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__DirectoryWriteException[] = {  {&_swigt__p_Mezzanine__DirectoryWriteException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Exception[] = {  {&_swigt__p_Mezzanine__InvalidAssignment, _p_Mezzanine__InvalidAssignmentTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorException, _p_Mezzanine__SyntaxErrorExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorXMLException, _p_Mezzanine__SyntaxErrorXMLExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorXPathException, _p_Mezzanine__SyntaxErrorXPathExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorLuaException, _p_Mezzanine__SyntaxErrorLuaExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptException, _p_Mezzanine__ScriptExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaErrErrException, _p_Mezzanine__ScriptLuaErrErrExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaException, _p_Mezzanine__ScriptLuaExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaYieldException, _p_Mezzanine__ScriptLuaYieldExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaRuntimeException, _p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityDuplicateException, _p_Mezzanine__InstanceIdentityDuplicateExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityNotFoundException, _p_Mezzanine__InstanceIdentityNotFoundExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityInvalidException, _p_Mezzanine__InstanceIdentityInvalidExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityException, _p_Mezzanine__InstanceIdentityExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__IOReadException, _p_Mezzanine__IOReadExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__IOWriteException, _p_Mezzanine__IOWriteExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__IOException, _p_Mezzanine__IOExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__FileException, _p_Mezzanine__FileExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__FileReadException, _p_Mezzanine__FileReadExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__FileWriteException, _p_Mezzanine__FileWriteExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__FileNotFoundException, _p_Mezzanine__FileNotFoundExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__Exception, 0, 0, 0},  {&_swigt__p_Mezzanine__NetworkException, _p_Mezzanine__NetworkExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkReadException, _p_Mezzanine__NetworkReadExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkWriteException, _p_Mezzanine__NetworkWriteExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkNotFoundException, _p_Mezzanine__NetworkNotFoundExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkURLException, _p_Mezzanine__NetworkURLExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkPermissionException, _p_Mezzanine__NetworkPermissionExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryPermissionException, _p_Mezzanine__DirectoryPermissionExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryNotFoundException, _p_Mezzanine__DirectoryNotFoundExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryWriteException, _p_Mezzanine__DirectoryWriteExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryReadException, _p_Mezzanine__DirectoryReadExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryException, _p_Mezzanine__DirectoryExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__FilePermissionException, _p_Mezzanine__FilePermissionExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__MemoryOutOfBoundsException, _p_Mezzanine__MemoryOutOfBoundsExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__OutOfMemoryException, _p_Mezzanine__OutOfMemoryExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__MemoryManagementException, _p_Mezzanine__MemoryManagementExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ParametersException, _p_Mezzanine__ParametersExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ParametersCastException, _p_Mezzanine__ParametersCastExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ParametersRangeException, _p_Mezzanine__ParametersRangeExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__ArithmeticException, _p_Mezzanine__ArithmeticExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InvalidVersionException, _p_Mezzanine__InvalidVersionExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InvalidStateException, _p_Mezzanine__InvalidStateExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__RenderingAPIException, _p_Mezzanine__RenderingAPIExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__RuntimeAssertionException, _p_Mezzanine__RuntimeAssertionExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__InternalException, _p_Mezzanine__InternalExceptionTo_p_Mezzanine__Exception, 0, 0},  {&_swigt__p_Mezzanine__NotImplementedException, _p_Mezzanine__NotImplementedExceptionTo_p_Mezzanine__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__FileException[] = {  {&_swigt__p_Mezzanine__FileException, 0, 0, 0},  {&_swigt__p_Mezzanine__FileReadException, _p_Mezzanine__FileReadExceptionTo_p_Mezzanine__FileException, 0, 0},  {&_swigt__p_Mezzanine__FileWriteException, _p_Mezzanine__FileWriteExceptionTo_p_Mezzanine__FileException, 0, 0},  {&_swigt__p_Mezzanine__FileNotFoundException, _p_Mezzanine__FileNotFoundExceptionTo_p_Mezzanine__FileException, 0, 0},  {&_swigt__p_Mezzanine__FilePermissionException, _p_Mezzanine__FilePermissionExceptionTo_p_Mezzanine__FileException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__FileNotFoundException[] = {  {&_swigt__p_Mezzanine__FileNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__FilePermissionException[] = {  {&_swigt__p_Mezzanine__FilePermissionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__FileReadException[] = {  {&_swigt__p_Mezzanine__FileReadException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__FileWriteException[] = {  {&_swigt__p_Mezzanine__FileWriteException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Graphics__Mesh[] = {  {&_swigt__p_Mezzanine__Graphics__Mesh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__IOException[] = {  {&_swigt__p_Mezzanine__NetworkNotFoundException, _p_Mezzanine__NetworkNotFoundExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__NetworkWriteException, _p_Mezzanine__NetworkWriteExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__NetworkReadException, _p_Mezzanine__NetworkReadExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__NetworkException, _p_Mezzanine__NetworkExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryPermissionException, _p_Mezzanine__DirectoryPermissionExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryNotFoundException, _p_Mezzanine__DirectoryNotFoundExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryWriteException, _p_Mezzanine__DirectoryWriteExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryReadException, _p_Mezzanine__DirectoryReadExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__DirectoryException, _p_Mezzanine__DirectoryExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__FilePermissionException, _p_Mezzanine__FilePermissionExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__FileNotFoundException, _p_Mezzanine__FileNotFoundExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__FileWriteException, _p_Mezzanine__FileWriteExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__FileReadException, _p_Mezzanine__FileReadExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__IOException, 0, 0, 0},  {&_swigt__p_Mezzanine__NetworkURLException, _p_Mezzanine__NetworkURLExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__NetworkPermissionException, _p_Mezzanine__NetworkPermissionExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__FileException, _p_Mezzanine__FileExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__IOWriteException, _p_Mezzanine__IOWriteExceptionTo_p_Mezzanine__IOException, 0, 0},  {&_swigt__p_Mezzanine__IOReadException, _p_Mezzanine__IOReadExceptionTo_p_Mezzanine__IOException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__IOReadException[] = {  {&_swigt__p_Mezzanine__IOReadException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__IOWriteException[] = {  {&_swigt__p_Mezzanine__IOWriteException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InstanceIdentityDuplicateException[] = {  {&_swigt__p_Mezzanine__InstanceIdentityDuplicateException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InstanceIdentityException[] = {  {&_swigt__p_Mezzanine__InstanceIdentityException, 0, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityInvalidException, _p_Mezzanine__InstanceIdentityInvalidExceptionTo_p_Mezzanine__InstanceIdentityException, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityNotFoundException, _p_Mezzanine__InstanceIdentityNotFoundExceptionTo_p_Mezzanine__InstanceIdentityException, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityDuplicateException, _p_Mezzanine__InstanceIdentityDuplicateExceptionTo_p_Mezzanine__InstanceIdentityException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InstanceIdentityInvalidException[] = {  {&_swigt__p_Mezzanine__InstanceIdentityInvalidException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InstanceIdentityNotFoundException[] = {  {&_swigt__p_Mezzanine__InstanceIdentityNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InternalException[] = {  {&_swigt__p_Mezzanine__InternalException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InvalidAssignment[] = {  {&_swigt__p_Mezzanine__InvalidAssignment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InvalidStateException[] = {  {&_swigt__p_Mezzanine__InvalidStateException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__InvalidVersionException[] = {  {&_swigt__p_Mezzanine__InvalidVersionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Matrix3x3[] = {  {&_swigt__p_Mezzanine__Matrix3x3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__MemoryManagementException[] = {  {&_swigt__p_Mezzanine__MemoryManagementException, 0, 0, 0},  {&_swigt__p_Mezzanine__OutOfMemoryException, _p_Mezzanine__OutOfMemoryExceptionTo_p_Mezzanine__MemoryManagementException, 0, 0},  {&_swigt__p_Mezzanine__MemoryOutOfBoundsException, _p_Mezzanine__MemoryOutOfBoundsExceptionTo_p_Mezzanine__MemoryManagementException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__MemoryOutOfBoundsException[] = {  {&_swigt__p_Mezzanine__MemoryOutOfBoundsException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NetworkException[] = {  {&_swigt__p_Mezzanine__NetworkException, 0, 0, 0},  {&_swigt__p_Mezzanine__NetworkReadException, _p_Mezzanine__NetworkReadExceptionTo_p_Mezzanine__NetworkException, 0, 0},  {&_swigt__p_Mezzanine__NetworkWriteException, _p_Mezzanine__NetworkWriteExceptionTo_p_Mezzanine__NetworkException, 0, 0},  {&_swigt__p_Mezzanine__NetworkNotFoundException, _p_Mezzanine__NetworkNotFoundExceptionTo_p_Mezzanine__NetworkException, 0, 0},  {&_swigt__p_Mezzanine__NetworkURLException, _p_Mezzanine__NetworkURLExceptionTo_p_Mezzanine__NetworkException, 0, 0},  {&_swigt__p_Mezzanine__NetworkPermissionException, _p_Mezzanine__NetworkPermissionExceptionTo_p_Mezzanine__NetworkException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NetworkNotFoundException[] = {  {&_swigt__p_Mezzanine__NetworkNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NetworkPermissionException[] = {  {&_swigt__p_Mezzanine__NetworkPermissionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NetworkReadException[] = {  {&_swigt__p_Mezzanine__NetworkReadException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NetworkURLException[] = {  {&_swigt__p_Mezzanine__NetworkURLException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NetworkWriteException[] = {  {&_swigt__p_Mezzanine__NetworkWriteException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__NotImplementedException[] = {  {&_swigt__p_Mezzanine__NotImplementedException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__OutOfMemoryException[] = {  {&_swigt__p_Mezzanine__OutOfMemoryException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ParametersCastException[] = {  {&_swigt__p_Mezzanine__ParametersCastException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ParametersException[] = {  {&_swigt__p_Mezzanine__ParametersException, 0, 0, 0},  {&_swigt__p_Mezzanine__ParametersCastException, _p_Mezzanine__ParametersCastExceptionTo_p_Mezzanine__ParametersException, 0, 0},  {&_swigt__p_Mezzanine__ParametersRangeException, _p_Mezzanine__ParametersRangeExceptionTo_p_Mezzanine__ParametersException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ParametersRangeException[] = {  {&_swigt__p_Mezzanine__ParametersRangeException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__BoxCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__BoxCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CapsuleCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__CapsuleCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CollidablePair[] = {  {&_swigt__p_Mezzanine__Physics__CollidablePair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CollidableProxy[] = {  {&_swigt__p_Mezzanine__Physics__CollidableProxy, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__GhostProxy, _p_Mezzanine__Physics__GhostProxyTo_p_Mezzanine__Physics__CollidableProxy, 0, 0},  {&_swigt__p_Mezzanine__Physics__SoftProxy, _p_Mezzanine__Physics__SoftProxyTo_p_Mezzanine__Physics__CollidableProxy, 0, 0},  {&_swigt__p_Mezzanine__Physics__RigidProxy, _p_Mezzanine__Physics__RigidProxyTo_p_Mezzanine__Physics__CollidableProxy, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__Collision[] = {  {&_swigt__p_Mezzanine__Physics__Collision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__PlaneCollisionShape, _p_Mezzanine__Physics__PlaneCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__HeightfieldCollisionShape, _p_Mezzanine__Physics__HeightfieldCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__FieldCollisionShape, _p_Mezzanine__Physics__FieldCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__StaticMeshCollisionShape, _p_Mezzanine__Physics__StaticMeshCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__SoftCollisionShape, _p_Mezzanine__Physics__SoftCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__DynamicMeshCollisionShape, _p_Mezzanine__Physics__DynamicMeshCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__MeshCollisionShape, _p_Mezzanine__Physics__MeshCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__CylinderCollisionShape, _p_Mezzanine__Physics__CylinderCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__ConvexHullCollisionShape, _p_Mezzanine__Physics__ConvexHullCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__ConeCollisionShape, _p_Mezzanine__Physics__ConeCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__CompoundCollisionShape, _p_Mezzanine__Physics__CompoundCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__CapsuleCollisionShape, _p_Mezzanine__Physics__CapsuleCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__BoxCollisionShape, _p_Mezzanine__Physics__BoxCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__CollisionShape, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__MultiSphereCollisionShape, _p_Mezzanine__Physics__MultiSphereCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__PrimitiveCollisionShape, _p_Mezzanine__Physics__PrimitiveCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__SphereCollisionShape, _p_Mezzanine__Physics__SphereCollisionShapeTo_p_Mezzanine__Physics__CollisionShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CollisionShapeDeSerializer[] = {  {&_swigt__p_Mezzanine__Physics__CollisionShapeDeSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CollisionShapeManager[] = {  {&_swigt__p_Mezzanine__Physics__CollisionShapeManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator[] = {  {&_swigt__p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CompoundCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__CompoundCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__ConeCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__ConeCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__Constraint[] = {  {&_swigt__p_Mezzanine__Physics__Constraint, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__DualTransformConstraint, _p_Mezzanine__Physics__DualTransformConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__Generic6DofConstraint, _p_Mezzanine__Physics__Generic6DofConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__Generic6DofSpringConstraint, _p_Mezzanine__Physics__Generic6DofSpringConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__UniversalConstraint, _p_Mezzanine__Physics__UniversalConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__HingeConstraint, _p_Mezzanine__Physics__HingeConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__SliderConstraint, _p_Mezzanine__Physics__SliderConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__GearConstraint, _p_Mezzanine__Physics__GearConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__Point2PointConstraint, _p_Mezzanine__Physics__Point2PointConstraintTo_p_Mezzanine__Physics__Constraint, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__ConvexHullCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__ConvexHullCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__CylinderCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__CylinderCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__DebugDrawWorkUnit[] = {  {&_swigt__p_Mezzanine__Physics__DebugDrawWorkUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory[] = {  {&_swigt__p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__DefaultPhysicsManagerFactory[] = {  {&_swigt__p_Mezzanine__Physics__DefaultPhysicsManagerFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__DualTransformConstraint[] = {  {&_swigt__p_Mezzanine__Physics__DualTransformConstraint, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__Generic6DofConstraint, _p_Mezzanine__Physics__Generic6DofConstraintTo_p_Mezzanine__Physics__DualTransformConstraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__Generic6DofSpringConstraint, _p_Mezzanine__Physics__Generic6DofSpringConstraintTo_p_Mezzanine__Physics__DualTransformConstraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__UniversalConstraint, _p_Mezzanine__Physics__UniversalConstraintTo_p_Mezzanine__Physics__DualTransformConstraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__HingeConstraint, _p_Mezzanine__Physics__HingeConstraintTo_p_Mezzanine__Physics__DualTransformConstraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__SliderConstraint, _p_Mezzanine__Physics__SliderConstraintTo_p_Mezzanine__Physics__DualTransformConstraint, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__DynamicMeshCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__DynamicMeshCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__FieldCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__FieldCollisionShape, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__HeightfieldCollisionShape, _p_Mezzanine__Physics__HeightfieldCollisionShapeTo_p_Mezzanine__Physics__FieldCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__PlaneCollisionShape, _p_Mezzanine__Physics__PlaneCollisionShapeTo_p_Mezzanine__Physics__FieldCollisionShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__GearConstraint[] = {  {&_swigt__p_Mezzanine__Physics__GearConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__Generic6DofConstraint[] = {  {&_swigt__p_Mezzanine__Physics__Generic6DofConstraint, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__Generic6DofSpringConstraint, _p_Mezzanine__Physics__Generic6DofSpringConstraintTo_p_Mezzanine__Physics__Generic6DofConstraint, 0, 0},  {&_swigt__p_Mezzanine__Physics__UniversalConstraint, _p_Mezzanine__Physics__UniversalConstraintTo_p_Mezzanine__Physics__Generic6DofConstraint, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__Generic6DofSpringConstraint[] = {  {&_swigt__p_Mezzanine__Physics__Generic6DofSpringConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__GhostProxy[] = {  {&_swigt__p_Mezzanine__Physics__GhostProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__HeightfieldCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__HeightfieldCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__HingeConstraint[] = {  {&_swigt__p_Mezzanine__Physics__HingeConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__ManagerConstructionInfo[] = {  {&_swigt__p_Mezzanine__Physics__ManagerConstructionInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__MeshCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__MeshCollisionShape, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__DynamicMeshCollisionShape, _p_Mezzanine__Physics__DynamicMeshCollisionShapeTo_p_Mezzanine__Physics__MeshCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__SoftCollisionShape, _p_Mezzanine__Physics__SoftCollisionShapeTo_p_Mezzanine__Physics__MeshCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__StaticMeshCollisionShape, _p_Mezzanine__Physics__StaticMeshCollisionShapeTo_p_Mezzanine__Physics__MeshCollisionShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__MultiSphereCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__MultiSphereCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__PhysicsManager[] = {  {&_swigt__p_Mezzanine__Physics__PhysicsManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator[] = {  {&_swigt__p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__PlaneCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__PlaneCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__Point2PointConstraint[] = {  {&_swigt__p_Mezzanine__Physics__Point2PointConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__PrimitiveCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__BoxCollisionShape, _p_Mezzanine__Physics__BoxCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__CapsuleCollisionShape, _p_Mezzanine__Physics__CapsuleCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__ConeCollisionShape, _p_Mezzanine__Physics__ConeCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__ConvexHullCollisionShape, _p_Mezzanine__Physics__ConvexHullCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__CylinderCollisionShape, _p_Mezzanine__Physics__CylinderCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__MultiSphereCollisionShape, _p_Mezzanine__Physics__MultiSphereCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},  {&_swigt__p_Mezzanine__Physics__SphereCollisionShape, _p_Mezzanine__Physics__SphereCollisionShapeTo_p_Mezzanine__Physics__PrimitiveCollisionShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__RigidProxy[] = {  {&_swigt__p_Mezzanine__Physics__RigidProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__SimulationMonopolyWorkUnit[] = {  {&_swigt__p_Mezzanine__Physics__SimulationMonopolyWorkUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__SimulationWorkUnit[] = {  {&_swigt__p_Mezzanine__Physics__SimulationWorkUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__SliderConstraint[] = {  {&_swigt__p_Mezzanine__Physics__SliderConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__SoftCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__SoftCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__SoftProxy[] = {  {&_swigt__p_Mezzanine__Physics__SoftProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__SphereCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__SphereCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__StaticMeshCollisionShape[] = {  {&_swigt__p_Mezzanine__Physics__StaticMeshCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__StickyConstraintConstructionInfo[] = {  {&_swigt__p_Mezzanine__Physics__StickyConstraintConstructionInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__StickyData[] = {  {&_swigt__p_Mezzanine__Physics__StickyData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__UniversalConstraint[] = {  {&_swigt__p_Mezzanine__Physics__UniversalConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit[] = {  {&_swigt__p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Plane[] = {  {&_swigt__p_Mezzanine__Plane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Quaternion[] = {  {&_swigt__p_Mezzanine__Quaternion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Ray[] = {  {&_swigt__p_Mezzanine__Ray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__RenderingAPIException[] = {  {&_swigt__p_Mezzanine__RenderingAPIException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__RuntimeAssertionException[] = {  {&_swigt__p_Mezzanine__RuntimeAssertionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ScriptException[] = {  {&_swigt__p_Mezzanine__ScriptException, 0, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaException, _p_Mezzanine__ScriptLuaExceptionTo_p_Mezzanine__ScriptException, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaYieldException, _p_Mezzanine__ScriptLuaYieldExceptionTo_p_Mezzanine__ScriptException, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaRuntimeException, _p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_Mezzanine__ScriptException, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaErrErrException, _p_Mezzanine__ScriptLuaErrErrExceptionTo_p_Mezzanine__ScriptException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ScriptLuaErrErrException[] = {  {&_swigt__p_Mezzanine__ScriptLuaErrErrException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ScriptLuaException[] = {  {&_swigt__p_Mezzanine__ScriptLuaException, 0, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaYieldException, _p_Mezzanine__ScriptLuaYieldExceptionTo_p_Mezzanine__ScriptLuaException, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaRuntimeException, _p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_Mezzanine__ScriptLuaException, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaErrErrException, _p_Mezzanine__ScriptLuaErrErrExceptionTo_p_Mezzanine__ScriptLuaException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ScriptLuaRuntimeException[] = {  {&_swigt__p_Mezzanine__ScriptLuaRuntimeException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__ScriptLuaYieldException[] = {  {&_swigt__p_Mezzanine__ScriptLuaYieldException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__SingletonT_CollisionShapeManager_t[] = {  {&_swigt__p_Mezzanine__SingletonT_CollisionShapeManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Sphere[] = {  {&_swigt__p_Mezzanine__Sphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__SyntaxErrorException[] = {  {&_swigt__p_Mezzanine__SyntaxErrorException, 0, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorXMLException, _p_Mezzanine__SyntaxErrorXMLExceptionTo_p_Mezzanine__SyntaxErrorException, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorXPathException, _p_Mezzanine__SyntaxErrorXPathExceptionTo_p_Mezzanine__SyntaxErrorException, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorLuaException, _p_Mezzanine__SyntaxErrorLuaExceptionTo_p_Mezzanine__SyntaxErrorException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__SyntaxErrorLuaException[] = {  {&_swigt__p_Mezzanine__SyntaxErrorLuaException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__SyntaxErrorXMLException[] = {  {&_swigt__p_Mezzanine__SyntaxErrorXMLException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__SyntaxErrorXPathException[] = {  {&_swigt__p_Mezzanine__SyntaxErrorXPathException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type[] = {  {&_swigt__p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Threading__DefaultWorkUnit[] = {  {&_swigt__p_Mezzanine__Threading__DefaultWorkUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Threading__RawFile[] = {  {&_swigt__p_Mezzanine__Threading__RawFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Transform[] = {  {&_swigt__p_Mezzanine__Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__TransformableChildObject[] = {  {&_swigt__p_Mezzanine__TransformableChildObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__TransformableObject[] = {  {&_swigt__p_Mezzanine__Physics__CollidableProxy, _p_Mezzanine__Physics__CollidableProxyTo_p_Mezzanine__TransformableObject, 0, 0},  {&_swigt__p_Mezzanine__Physics__GhostProxy, _p_Mezzanine__Physics__GhostProxyTo_p_Mezzanine__TransformableObject, 0, 0},  {&_swigt__p_Mezzanine__Physics__SoftProxy, _p_Mezzanine__Physics__SoftProxyTo_p_Mezzanine__TransformableObject, 0, 0},  {&_swigt__p_Mezzanine__TransformableObject, 0, 0, 0},  {&_swigt__p_Mezzanine__Physics__RigidProxy, _p_Mezzanine__Physics__RigidProxyTo_p_Mezzanine__TransformableObject, 0, 0},  {&_swigt__p_Mezzanine__WorldProxy, _p_Mezzanine__WorldProxyTo_p_Mezzanine__TransformableObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__Vector3[] = {  {&_swigt__p_Mezzanine__Vector3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__WorldManager[] = {  {&_swigt__p_Mezzanine__WorldManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__WorldObject[] = {  {&_swigt__p_Mezzanine__WorldObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__WorldProxy[] = {  {&_swigt__p_Mezzanine__Physics__CollidableProxy, _p_Mezzanine__Physics__CollidableProxyTo_p_Mezzanine__WorldProxy, 0, 0},  {&_swigt__p_Mezzanine__Physics__GhostProxy, _p_Mezzanine__Physics__GhostProxyTo_p_Mezzanine__WorldProxy, 0, 0},  {&_swigt__p_Mezzanine__Physics__SoftProxy, _p_Mezzanine__Physics__SoftProxyTo_p_Mezzanine__WorldProxy, 0, 0},  {&_swigt__p_Mezzanine__Physics__RigidProxy, _p_Mezzanine__Physics__RigidProxyTo_p_Mezzanine__WorldProxy, 0, 0},  {&_swigt__p_Mezzanine__WorldProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mezzanine__WorldTrigger[] = {  {&_swigt__p_Mezzanine__WorldTrigger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Plane[] = {  {&_swigt__p_Ogre__Plane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Quaternion[] = {  {&_swigt__p_Ogre__Quaternion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Vector3[] = {  {&_swigt__p_Ogre__Vector3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParamList[] = {  {&_swigt__p_ParamList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ProxyContainer[] = {  {&_swigt__p_ProxyContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ProxyIterator[] = {  {&_swigt__p_ProxyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RayTestResult[] = {  {&_swigt__p_RayTestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDL_Event[] = {  {&_swigt__p_SDL_Event, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShapeMap[] = {  {&_swigt__p_ShapeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShapeMapIterator[] = {  {&_swigt__p_ShapeMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShapeVector[] = {  {&_swigt__p_ShapeVector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShapeVectorIterator[] = {  {&_swigt__p_ShapeVectorIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StandardAxis[] = {  {&_swigt__p_StandardAxis, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Transform[] = {  {&_swigt__p_Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WorldTriggerContainer[] = {  {&_swigt__p_WorldTriggerContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WorldTriggerIterator[] = {  {&_swigt__p_WorldTriggerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XML__Node[] = {  {&_swigt__p_XML__Node, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btBoxShape[] = {  {&_swigt__p_btBoxShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btBvhTriangleMeshShape[] = {  {&_swigt__p_btBvhTriangleMeshShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btCapsuleShape[] = {  {&_swigt__p_btCapsuleShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btCollisionObject[] = {  {&_swigt__p_btCollisionObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btCollisionShape[] = {  {&_swigt__p_btCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btCompoundShape[] = {  {&_swigt__p_btCompoundShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btConcaveShape[] = {  {&_swigt__p_btConcaveShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btConeShape[] = {  {&_swigt__p_btConeShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btConvexHullShape[] = {  {&_swigt__p_btConvexHullShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btConvexInternalShape[] = {  {&_swigt__p_btConvexInternalShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btCylinderShape[] = {  {&_swigt__p_btCylinderShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btGImpactMeshShape[] = {  {&_swigt__p_btGImpactMeshShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btHeightfieldTerrainShape[] = {  {&_swigt__p_btHeightfieldTerrainShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btMultiSphereShape[] = {  {&_swigt__p_btMultiSphereShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btPairCachingGhostObject[] = {  {&_swigt__p_btPairCachingGhostObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btQuaternion[] = {  {&_swigt__p_btQuaternion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btRigidBody[] = {  {&_swigt__p_btRigidBody, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btSoftBody[] = {  {&_swigt__p_btSoftBody, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btSoftBodyCollisionShape[] = {  {&_swigt__p_btSoftBodyCollisionShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btSphereShape[] = {  {&_swigt__p_btSphereShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btStaticPlaneShape[] = {  {&_swigt__p_btStaticPlaneShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btTransform[] = {  {&_swigt__p_btTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btTypedConstraint[] = {  {&_swigt__p_btTypedConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_btVector3[] = {  {&_swigt__p_btVector3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__exception[] = {  {&_swigt__p_Mezzanine__InvalidAssignment, _p_Mezzanine__InvalidAssignmentTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorXMLException, _p_Mezzanine__SyntaxErrorXMLExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorXPathException, _p_Mezzanine__SyntaxErrorXPathExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorLuaException, _p_Mezzanine__SyntaxErrorLuaExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptException, _p_Mezzanine__ScriptExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaErrErrException, _p_Mezzanine__ScriptLuaErrErrExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaException, _p_Mezzanine__ScriptLuaExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaYieldException, _p_Mezzanine__ScriptLuaYieldExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ScriptLuaRuntimeException, _p_Mezzanine__ScriptLuaRuntimeExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityDuplicateException, _p_Mezzanine__InstanceIdentityDuplicateExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityNotFoundException, _p_Mezzanine__InstanceIdentityNotFoundExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityInvalidException, _p_Mezzanine__InstanceIdentityInvalidExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InstanceIdentityException, _p_Mezzanine__InstanceIdentityExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__Exception, _p_Mezzanine__ExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__IOReadException, _p_Mezzanine__IOReadExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__IOWriteException, _p_Mezzanine__IOWriteExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkPermissionException, _p_Mezzanine__NetworkPermissionExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkURLException, _p_Mezzanine__NetworkURLExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkNotFoundException, _p_Mezzanine__NetworkNotFoundExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkWriteException, _p_Mezzanine__NetworkWriteExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkReadException, _p_Mezzanine__NetworkReadExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_std__exception, 0, 0, 0},  {&_swigt__p_Mezzanine__DirectoryPermissionException, _p_Mezzanine__DirectoryPermissionExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryNotFoundException, _p_Mezzanine__DirectoryNotFoundExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryWriteException, _p_Mezzanine__DirectoryWriteExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryReadException, _p_Mezzanine__DirectoryReadExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__DirectoryException, _p_Mezzanine__DirectoryExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__FilePermissionException, _p_Mezzanine__FilePermissionExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__FileNotFoundException, _p_Mezzanine__FileNotFoundExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__FileWriteException, _p_Mezzanine__FileWriteExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__FileReadException, _p_Mezzanine__FileReadExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__FileException, _p_Mezzanine__FileExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__IOException, _p_Mezzanine__IOExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NetworkException, _p_Mezzanine__NetworkExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__SyntaxErrorException, _p_Mezzanine__SyntaxErrorExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__MemoryOutOfBoundsException, _p_Mezzanine__MemoryOutOfBoundsExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__OutOfMemoryException, _p_Mezzanine__OutOfMemoryExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__MemoryManagementException, _p_Mezzanine__MemoryManagementExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ParametersException, _p_Mezzanine__ParametersExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ParametersCastException, _p_Mezzanine__ParametersCastExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ParametersRangeException, _p_Mezzanine__ParametersRangeExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__ArithmeticException, _p_Mezzanine__ArithmeticExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InvalidVersionException, _p_Mezzanine__InvalidVersionExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InvalidStateException, _p_Mezzanine__InvalidStateExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__RenderingAPIException, _p_Mezzanine__RenderingAPIExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__RuntimeAssertionException, _p_Mezzanine__RuntimeAssertionExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__InternalException, _p_Mezzanine__InternalExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Mezzanine__NotImplementedException, _p_Mezzanine__NotImplementedExceptionTo_p_std__exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__istream[] = {  {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_std__pairT_std__string_std__string_t_t[] = {  {&_swigt__p_std__listT_std__pairT_std__string_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t[] = {  {&_swigt__p_std__mapT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_bool_Mezzanine__Vector3_t[] = {  {&_swigt__p_std__pairT_bool_Mezzanine__Vector3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_std__string_t[] = {  {&_swigt__p_std__pairT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_std__string_t[] = {  {&_swigt__p_std__setT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__stringstream[] = {  {&_swigt__p_std__stringstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t[] = {  {&_swigt__p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Mezzanine__Physics__ConstraintParam_t[] = {  {&_swigt__p_std__vectorT_Mezzanine__Physics__ConstraintParam_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t[] = {  {&_swigt__p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t[] = {  {&_swigt__p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Mezzanine__Vector3_t[] = {  {&_swigt__p_std__vectorT_Mezzanine__Vector3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_float_t[] = {  {&_swigt__p_std__vectorT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_t[] = {  {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__wstring[] = {  {&_swigt__p_std__wstring, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_AxisAlignedBox,
  _swigc__p_AxisList,
  _swigc__p_ChannelType,
  _swigc__p_CollidablePair,
  _swigc__p_CollisionContainer,
  _swigc__p_CollisionIterator,
  _swigc__p_CollisionShapeManager,
  _swigc__p_CollisionSortPair,
  _swigc__p_ConstCollisionIterator,
  _swigc__p_ConstConstraintIterator,
  _swigc__p_ConstProxyIterator,
  _swigc__p_ConstShapeMapIterator,
  _swigc__p_ConstShapeVectorIterator,
  _swigc__p_ConstWorldTriggerIterator,
  _swigc__p_ConstraintContainer,
  _swigc__p_ConstraintIterator,
  _swigc__p_ManagerBase,
  _swigc__p_ManagerBase__ManagerType,
  _swigc__p_ManagerConstructionInfo,
  _swigc__p_Mezzanine__ArithmeticException,
  _swigc__p_Mezzanine__AxisAlignedBox,
  _swigc__p_Mezzanine__DirectoryException,
  _swigc__p_Mezzanine__DirectoryNotFoundException,
  _swigc__p_Mezzanine__DirectoryPermissionException,
  _swigc__p_Mezzanine__DirectoryReadException,
  _swigc__p_Mezzanine__DirectoryWriteException,
  _swigc__p_Mezzanine__Exception,
  _swigc__p_Mezzanine__FileException,
  _swigc__p_Mezzanine__FileNotFoundException,
  _swigc__p_Mezzanine__FilePermissionException,
  _swigc__p_Mezzanine__FileReadException,
  _swigc__p_Mezzanine__FileWriteException,
  _swigc__p_Mezzanine__Graphics__Mesh,
  _swigc__p_Mezzanine__IOException,
  _swigc__p_Mezzanine__IOReadException,
  _swigc__p_Mezzanine__IOWriteException,
  _swigc__p_Mezzanine__InstanceIdentityDuplicateException,
  _swigc__p_Mezzanine__InstanceIdentityException,
  _swigc__p_Mezzanine__InstanceIdentityInvalidException,
  _swigc__p_Mezzanine__InstanceIdentityNotFoundException,
  _swigc__p_Mezzanine__InternalException,
  _swigc__p_Mezzanine__InvalidAssignment,
  _swigc__p_Mezzanine__InvalidStateException,
  _swigc__p_Mezzanine__InvalidVersionException,
  _swigc__p_Mezzanine__Matrix3x3,
  _swigc__p_Mezzanine__MemoryManagementException,
  _swigc__p_Mezzanine__MemoryOutOfBoundsException,
  _swigc__p_Mezzanine__NetworkException,
  _swigc__p_Mezzanine__NetworkNotFoundException,
  _swigc__p_Mezzanine__NetworkPermissionException,
  _swigc__p_Mezzanine__NetworkReadException,
  _swigc__p_Mezzanine__NetworkURLException,
  _swigc__p_Mezzanine__NetworkWriteException,
  _swigc__p_Mezzanine__NotImplementedException,
  _swigc__p_Mezzanine__OutOfMemoryException,
  _swigc__p_Mezzanine__ParametersCastException,
  _swigc__p_Mezzanine__ParametersException,
  _swigc__p_Mezzanine__ParametersRangeException,
  _swigc__p_Mezzanine__Physics__BoxCollisionShape,
  _swigc__p_Mezzanine__Physics__CapsuleCollisionShape,
  _swigc__p_Mezzanine__Physics__CollidablePair,
  _swigc__p_Mezzanine__Physics__CollidableProxy,
  _swigc__p_Mezzanine__Physics__Collision,
  _swigc__p_Mezzanine__Physics__CollisionShape,
  _swigc__p_Mezzanine__Physics__CollisionShapeDeSerializer,
  _swigc__p_Mezzanine__Physics__CollisionShapeManager,
  _swigc__p_Mezzanine__Physics__CollisionShapeManager__ShapeMap__iterator,
  _swigc__p_Mezzanine__Physics__CompoundCollisionShape,
  _swigc__p_Mezzanine__Physics__ConeCollisionShape,
  _swigc__p_Mezzanine__Physics__Constraint,
  _swigc__p_Mezzanine__Physics__ConvexHullCollisionShape,
  _swigc__p_Mezzanine__Physics__CylinderCollisionShape,
  _swigc__p_Mezzanine__Physics__DebugDrawWorkUnit,
  _swigc__p_Mezzanine__Physics__DefaultCollisionShapeManagerFactory,
  _swigc__p_Mezzanine__Physics__DefaultPhysicsManagerFactory,
  _swigc__p_Mezzanine__Physics__DualTransformConstraint,
  _swigc__p_Mezzanine__Physics__DynamicMeshCollisionShape,
  _swigc__p_Mezzanine__Physics__FieldCollisionShape,
  _swigc__p_Mezzanine__Physics__GearConstraint,
  _swigc__p_Mezzanine__Physics__Generic6DofConstraint,
  _swigc__p_Mezzanine__Physics__Generic6DofSpringConstraint,
  _swigc__p_Mezzanine__Physics__GhostProxy,
  _swigc__p_Mezzanine__Physics__HeightfieldCollisionShape,
  _swigc__p_Mezzanine__Physics__HingeConstraint,
  _swigc__p_Mezzanine__Physics__ManagerConstructionInfo,
  _swigc__p_Mezzanine__Physics__MeshCollisionShape,
  _swigc__p_Mezzanine__Physics__MultiSphereCollisionShape,
  _swigc__p_Mezzanine__Physics__PhysicsManager,
  _swigc__p_Mezzanine__Physics__PhysicsManager__CollisionContainer__iterator,
  _swigc__p_Mezzanine__Physics__PlaneCollisionShape,
  _swigc__p_Mezzanine__Physics__Point2PointConstraint,
  _swigc__p_Mezzanine__Physics__PrimitiveCollisionShape,
  _swigc__p_Mezzanine__Physics__RigidProxy,
  _swigc__p_Mezzanine__Physics__SimulationMonopolyWorkUnit,
  _swigc__p_Mezzanine__Physics__SimulationWorkUnit,
  _swigc__p_Mezzanine__Physics__SliderConstraint,
  _swigc__p_Mezzanine__Physics__SoftCollisionShape,
  _swigc__p_Mezzanine__Physics__SoftProxy,
  _swigc__p_Mezzanine__Physics__SphereCollisionShape,
  _swigc__p_Mezzanine__Physics__StaticMeshCollisionShape,
  _swigc__p_Mezzanine__Physics__StickyConstraintConstructionInfo,
  _swigc__p_Mezzanine__Physics__StickyData,
  _swigc__p_Mezzanine__Physics__UniversalConstraint,
  _swigc__p_Mezzanine__Physics__WorldTriggerUpdateWorkUnit,
  _swigc__p_Mezzanine__Plane,
  _swigc__p_Mezzanine__Quaternion,
  _swigc__p_Mezzanine__Ray,
  _swigc__p_Mezzanine__RenderingAPIException,
  _swigc__p_Mezzanine__RuntimeAssertionException,
  _swigc__p_Mezzanine__ScriptException,
  _swigc__p_Mezzanine__ScriptLuaErrErrException,
  _swigc__p_Mezzanine__ScriptLuaException,
  _swigc__p_Mezzanine__ScriptLuaRuntimeException,
  _swigc__p_Mezzanine__ScriptLuaYieldException,
  _swigc__p_Mezzanine__SingletonT_CollisionShapeManager_t,
  _swigc__p_Mezzanine__Sphere,
  _swigc__p_Mezzanine__SyntaxErrorException,
  _swigc__p_Mezzanine__SyntaxErrorLuaException,
  _swigc__p_Mezzanine__SyntaxErrorXMLException,
  _swigc__p_Mezzanine__SyntaxErrorXPathException,
  _swigc__p_Mezzanine__Threading__DefaultThreadSpecificStorage__Type,
  _swigc__p_Mezzanine__Threading__DefaultWorkUnit,
  _swigc__p_Mezzanine__Threading__RawFile,
  _swigc__p_Mezzanine__Transform,
  _swigc__p_Mezzanine__TransformableChildObject,
  _swigc__p_Mezzanine__TransformableObject,
  _swigc__p_Mezzanine__Vector3,
  _swigc__p_Mezzanine__WorldManager,
  _swigc__p_Mezzanine__WorldObject,
  _swigc__p_Mezzanine__WorldProxy,
  _swigc__p_Mezzanine__WorldTrigger,
  _swigc__p_Ogre__Plane,
  _swigc__p_Ogre__Quaternion,
  _swigc__p_Ogre__Vector3,
  _swigc__p_ParamList,
  _swigc__p_ProxyContainer,
  _swigc__p_ProxyIterator,
  _swigc__p_RayTestResult,
  _swigc__p_SDL_Event,
  _swigc__p_ShapeMap,
  _swigc__p_ShapeMapIterator,
  _swigc__p_ShapeVector,
  _swigc__p_ShapeVectorIterator,
  _swigc__p_StandardAxis,
  _swigc__p_Transform,
  _swigc__p_WorldTriggerContainer,
  _swigc__p_WorldTriggerIterator,
  _swigc__p_XML__Node,
  _swigc__p_bool,
  _swigc__p_btBoxShape,
  _swigc__p_btBvhTriangleMeshShape,
  _swigc__p_btCapsuleShape,
  _swigc__p_btCollisionObject,
  _swigc__p_btCollisionShape,
  _swigc__p_btCompoundShape,
  _swigc__p_btConcaveShape,
  _swigc__p_btConeShape,
  _swigc__p_btConvexHullShape,
  _swigc__p_btConvexInternalShape,
  _swigc__p_btCylinderShape,
  _swigc__p_btGImpactMeshShape,
  _swigc__p_btHeightfieldTerrainShape,
  _swigc__p_btMultiSphereShape,
  _swigc__p_btPairCachingGhostObject,
  _swigc__p_btQuaternion,
  _swigc__p_btRigidBody,
  _swigc__p_btSoftBody,
  _swigc__p_btSoftBodyCollisionShape,
  _swigc__p_btSphereShape,
  _swigc__p_btStaticPlaneShape,
  _swigc__p_btTransform,
  _swigc__p_btTypedConstraint,
  _swigc__p_btVector3,
  _swigc__p_char,
  _swigc__p_double,
  _swigc__p_float,
  _swigc__p_int,
  _swigc__p_long_long,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_std__exception,
  _swigc__p_std__istream,
  _swigc__p_std__listT_std__pairT_std__string_std__string_t_t,
  _swigc__p_std__mapT_std__string_std__string_t,
  _swigc__p_std__pairT_bool_Mezzanine__Vector3_t,
  _swigc__p_std__pairT_std__string_std__string_t,
  _swigc__p_std__setT_std__string_t,
  _swigc__p_std__string,
  _swigc__p_std__stringstream,
  _swigc__p_std__vectorT_Mezzanine__Physics__CollisionShape_p_t,
  _swigc__p_std__vectorT_Mezzanine__Physics__ConstraintParam_t,
  _swigc__p_std__vectorT_Mezzanine__Physics__Generic6DofConstraint_p_t,
  _swigc__p_std__vectorT_Mezzanine__Physics__StickyConstraintConstructionInfo_t,
  _swigc__p_std__vectorT_Mezzanine__Vector3_t,
  _swigc__p_std__vectorT_float_t,
  _swigc__p_std__vectorT_int_t,
  _swigc__p_std__vectorT_std__string_t,
  _swigc__p_std__wstring,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic 
 * memory is used. Also, since swig_type_info structures store pointers to 
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization. 
 * The idea is that swig generates all the structures that are needed. 
 * The runtime then collects these partially filled structures. 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned staticly to an initial 
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it 
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded. 
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the 
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int found, init;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }

  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* When multiple interpeters are used, a module could have already been initialized in
     a different interpreter, but not yet have a pointer in this interpreter.
     In this case, we do not want to continue adding types... everything should be
     set up already */
  if (init == 0) return;

  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
  
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif

    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
    type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }

    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
    
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
    if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
    if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
      cast->type = ret;
      ret = 0;
    } else {
      /* Check for casting already in the list */
      swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
      if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
      if (!ocast) ret = 0;
    }
      }

      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;

#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
  printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;

  if (init_run) return;
  init_run = 1;

  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{ /* c-mode */
#endif
}
#endif



/* Forward declaration of where the user's %init{} gets inserted */
void SWIG_init_user(lua_State* L );
    
#ifdef __cplusplus
extern "C" {
#endif
/* this is the initialization function
  added at the very end of the code
  the function is always called SWIG_init, but an earlier #define will rename it
*/
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
LUALIB_API int SWIG_init(lua_State* L)
#else
SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
#endif
{
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
  int i;
  /* start with global table */
  lua_pushglobaltable (L);
  /* SWIG's internal initalisation */
  SWIG_InitializeModule((void*)L);
  SWIG_PropagateClientData();
#endif

#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
  /* add a global fn */
  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
  SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_equal);
  /* begin the module (its a table with the same name as the module) */
  SWIG_Lua_module_begin(L,SWIG_name);
  /* add commands/functions */
  for (i = 0; swig_commands[i].name; i++){
    SWIG_Lua_module_add_function(L,swig_commands[i].name,swig_commands[i].func);
  }
  /* add variables */
  for (i = 0; swig_variables[i].name; i++){
    SWIG_Lua_module_add_variable(L,swig_variables[i].name,swig_variables[i].get,swig_variables[i].set);
  }
#endif

#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
  /* set up base class pointers (the hierarchy) */
  for (i = 0; swig_types[i]; i++){
    if (swig_types[i]->clientdata){
      SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
    }
  }
  /* additional registration structs & classes in lua */
  for (i = 0; swig_types[i]; i++){
    if (swig_types[i]->clientdata){
      SWIG_Lua_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
    }
  }
#endif

#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
  /* constants */
  SWIG_Lua_InstallConstants(L,swig_constants);
#endif

#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
  /* invoke user-specific initialization */
  SWIG_init_user(L);
  /* end module */
  /* Note: We do not clean up the stack here (Lua will do this for us). At this
     point, we have the globals table and out module table on the stack. Returning
     one value makes the module table the result of the require command. */
  return 1;
#else
  return 0;
#endif
}

#ifdef __cplusplus
}
#endif


const char* SWIG_LUACODE=
  "";

void SWIG_init_user(lua_State* L)
{
  /* exec Lua code if applicable */
  SWIG_Lua_dostring(L,SWIG_LUACODE);
}